src/Repository/LessonRepository.php line 588

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.         $this->em->beginTransaction();
  1606.         
  1607.         try {
  1608.             $sql = "SELECT l.id 
  1609.                     FROM EADPlataforma:Lesson AS l
  1610.                     WHERE l.course = :courseId 
  1611.                     AND l.lessonModule = :lessonModuleId
  1612.                     AND l.deleted = :deleted
  1613.                     ORDER BY l.order ASC";
  1615.             $query = $this->em->createQuery($sql);
  1616.             $query->setParameter('courseId', $courseId);
  1617.             $query->setParameter('lessonModuleId', $lessonModuleId);
  1618.             $query->setParameter('deleted', $isDelete);
  1620.             $lessons = $query->getResult();
  1622.             $order = 1;
  1623.             foreach ($lessons as $lesson) {
  1624.                 $updateSql = "UPDATE EADPlataforma:Lesson AS l
  1625.                             SET l.order = :order
  1626.                             WHERE l.id = :id";
  1628.                 $updateQuery = $this->em->createQuery($updateSql);
  1629.                 $updateQuery->setParameter('order', $order);
  1630.                 $updateQuery->setParameter('id', $lesson['id']);
  1631.                 $updateQuery->execute();
  1633.                 $order++;
  1634.             }
  1636.             $maxOrder = count($lessons);
  1638.             if ($newOrder < 1) {
  1639.                 $newOrder = 1;
  1640.             } elseif ($newOrder > $maxOrder) {
  1641.                 $newOrder = $maxOrder;
  1642.             }
  1644.             if ($oldOrder != $newOrder) {
  1645.                 $sql = ($oldOrder < $newOrder) 
  1646.                     ? "UPDATE EADPlataforma:Lesson AS l
  1647.                     SET l.order = l.order - 1
  1648.                     WHERE l.order > :oldOrder
  1649.                     AND l.order <= :newOrder
  1650.                     AND l.course = :courseId
  1651.                     AND l.lessonModule = :lessonModuleId
  1652.                     AND l.deleted = :deleted"
  1653.                     : "UPDATE EADPlataforma:Lesson AS l
  1654.                     SET l.order = l.order + 1
  1655.                     WHERE l.order < :oldOrder
  1656.                     AND l.order >= :newOrder
  1657.                     AND l.course = :courseId
  1658.                     AND l.lessonModule = :lessonModuleId
  1659.                     AND l.deleted = :deleted";
  1661.                 $shiftQuery = $this->em->createQuery($sql);
  1662.                 $shiftQuery->setParameter('oldOrder', $oldOrder);
  1663.                 $shiftQuery->setParameter('newOrder', $newOrder);
  1664.                 $shiftQuery->setParameter('courseId', $courseId);
  1665.                 $shiftQuery->setParameter('lessonModuleId', $lessonModuleId);
  1666.                 $shiftQuery->setParameter('deleted', $isDelete);
  1667.                 $shiftQuery->execute();
  1668.             }
  1670.             $finalSql = "UPDATE EADPlataforma:Lesson AS l
  1671.                         SET l.order = :newOrder
  1672.                         WHERE l.id = :lessonId";
  1674.             $finalUpdateQuery = $this->em->createQuery($finalSql);
  1675.             $finalUpdateQuery->setParameter('newOrder', $newOrder);
  1676.             $finalUpdateQuery->setParameter('lessonId', $oldOrder);
  1677.             $finalUpdateQuery->execute();
  1679.             $this->em->commit();
  1680.         } catch (\Exception $e) {
  1681.             $this->em->rollback();
  1682.             throw $e;
  1683.         }
  1684.     }
  1686.     public function copyLesson(
  1687.         LessonModule $newModule, 
  1688.         Lesson $lesson, 
  1689.         $isPartial = false,
  1690.         $isModulePartial = false, 
  1691.         $copyType = null
  1692.     )
  1693.     {
  1694.         $course = $newModule->getCourse();
  1695.         $courseId = $course->getId();
  1696.     
  1697.         $newLesson = clone $lesson;
  1698.         $newLesson->setLessonModule($newModule);
  1699.         $newLesson->setCourse($course);
  1701.         if($copyType == LessonEnum::COPY_PUBLISHED){
  1702.             $newLesson->setStatus(LessonEnum::PUBLISHED);
  1703.         }else if($copyType == LessonEnum::COPY_DRAFT){
  1704.             $newLesson->setStatus(LessonEnum::DRAFT);
  1705.         }
  1706.         
  1707.         if($isPartial){
  1708.             $lastOrder = $this->count([ 
  1709.                 "course" => $courseId,
  1710.                 "lessonModule" => $newModule->getId(),
  1711.                 "deleted" => LessonEnum::ITEM_NO_DELETED 
  1712.             ]);
  1713.             $newLesson->setOrder($lastOrder + 1);
  1714.         }
  1716.         $this->em->persist($newLesson);
  1717.         $this->em->flush();
  1719.         if($isPartial || $isModulePartial){
  1720.             $userLessonId = $newLesson->getUser()->getId();
  1721.             $courseTeam = $this->em->getRepository(CourseTeam::class)->findOneBy([
  1722.                 "course" => $courseId, 
  1723.                 "user" => $userLessonId,
  1724.                 "deleted" => LessonEnum::ITEM_NO_DELETED
  1725.             ]);
  1726.             
  1727.             if(!$courseTeam){
  1728.                 $newCourseTeam = new CourseTeam();
  1729.                 $newCourseTeam->setCourse($course);
  1730.                 $newCourseTeam->setUser($newLesson->getUser());
  1732.                 $this->em->persist($newCourseTeam);
  1733.                 $this->em->flush();
  1734.             }
  1735.         }
  1736.         
  1737.         $files = $this->em->getRepository(LessonXLibrary::class)->findBy([
  1738.             "lesson"=> $lesson->getId(),
  1739.             "deleted"=> LessonXLibraryEnum::ITEM_NO_DELETED
  1740.         ]);
  1741.         
  1742.         if($files){
  1743.             foreach ($files as $key => $file) {
  1744.                 $newFile = clone $file;
  1745.                 $newFile->setLesson($newLesson);
  1746.                 
  1747.                 $this->em->persist($newFile);
  1748.                 $this->em->flush();
  1749.             }
  1750.         }
  1751.         
  1752.         $this->em->getRepository(Exam::class)->copyExamByLesson($lesson, $newLesson);
  1753.         $this->em->getRepository(Exam::class)->copyQuizByLesson($lesson, $newLesson);
  1754.     }
  1756.     public function notifyStudentsLesson(Lesson $lesson, $type)
  1757.     {   
  1758.         if(!$this->configuration->checkModuleIsAbleOnPlan('notificationFunction')){
  1759.             return;
  1760.         }
  1762.         $today = date('Y-m-d');
  1763.         $dateLastNotify = $lesson->getDateLastNotify('Y-m-d');
  1765.         if($today != $dateLastNotify && $lesson->getStatus() == LessonEnum::PUBLISHED){
  1766.             $course = $lesson->getCourse();
  1767.             $lessonModule = $lesson->getLessonModule();
  1769.             if(
  1770.                 $course->getStatus() == CourseEnum::PUBLISHED && 
  1771.                 $lessonModule->getStatus() == LessonModuleEnum::PUBLISHED
  1772.             ){
  1773.                 $taskQueueService = $this->generalService->getService('TaskQueueService');
  1774.                 $enrollmentRepository = $this->em->getRepository(Enrollment::class);
  1775.                 
  1776.                 $enrollments = $enrollmentRepository->getEnrollmentsByCourse(
  1777.                     $course->getId(), 
  1778.                     EnrollmentEnum::STATUS_ACTIVE
  1779.                 );
  1781.                 foreach ($enrollments as $key => $enrollment) {
  1782.                     if($enrollment->getUser()->getAllowNotifyNewLesson() == LessonEnum::YES){
  1783.                         $taskQueueService->insert($type, $enrollment->getUser(), $lesson->getId());
  1784.                     }
  1785.                 }
  1787.                 $lesson->setDateLastNotify(date('Y-m-d H:i:s'));
  1788.                 $this->em->flush();
  1789.             }
  1790.         }
  1791.     }
  1793.     public function lessonUpdateOrder($modules)
  1794.     {
  1795.         $dqlModule = "UPDATE EADPlataforma:LessonModule AS lm SET lm.order = CASE";
  1796.         $idModules = "";
  1798.         $dqlExam = "";
  1799.         $newModuleId = "";
  1800.         $whereExam = "";
  1802.         $caseLesson1 = " l.order = CASE ";
  1803.         $caseLesson2 = " l.lessonModule = CASE ";
  1804.         $caseLesson3 = " e.lessonModule = CASE ";
  1806.         $idsLesson = "";
  1808.         foreach ($modules as $key => $value) {
  1809.             
  1810.             $orderNew = $key + 1;
  1811.             $dqlModule .= " WHEN lm.id = {$value->moduleId} THEN {$orderNew}";
  1813.             if(empty($idModules)){
  1814.                 $idModules .= "{$value->moduleId}";
  1815.             }else{
  1816.                 $idModules .= ", {$value->moduleId}";
  1817.             }
  1819.             foreach ($value->lessons as $key_lesson => $valLesson) {
  1820.                 if(!empty($valLesson->lessonId)){
  1821.                     $ordemNewLesson = $key_lesson + 1;
  1822.                 
  1823.                     $caseLesson1 .= " WHEN l.id = {$valLesson->lessonId} THEN {$ordemNewLesson}";
  1824.                     $caseLesson2 .= " WHEN l.id = {$valLesson->lessonId} THEN {$value->moduleId}";
  1825.                     $caseLesson3 .= " WHEN e.lesson = {$valLesson->lessonId} THEN {$value->moduleId}";
  1826.                 
  1827.                     if(empty($idsLesson)){
  1828.                         $idsLesson .= " {$valLesson->lessonId} ";
  1829.                     }else{
  1830.                         $idsLesson .= ", {$valLesson->lessonId} ";
  1831.                     }
  1832.                 }
  1833.             }
  1834.         }
  1835.         
  1836.         $dqlModule .= " ELSE lm.order END WHERE lm.id IN ({$idModules}) ";
  1838.         $dqlLesson = "UPDATE EADPlataforma:Lesson AS l 
  1839.                       SET {$caseLesson1} ELSE l.order END, 
  1840.                           {$caseLesson2} ELSE IDENTITY(l.lessonModule) END 
  1841.                      WHERE l.id IN ({$idsLesson}) ";
  1843.         $dqlExam = "UPDATE EADPlataforma:Exam AS e
  1844.                     SET {$caseLesson3} ELSE IDENTITY(e.lessonModule) END 
  1845.                     WHERE e.lesson IN ({$idsLesson}) ";
  1847.         $query = $this->em->createQuery($dqlModule);
  1848.         $queryLesson = $this->em->createQuery($dqlLesson);
  1849.         $queryExam = $this->em->createQuery($dqlExam);
  1851.         $query->execute();
  1852.         $queryLesson->execute();
  1853.         $queryExam->execute();
  1854.     }
  1856.     public function getLessonPublicNumber(
  1857.         Course $course, 
  1858.         ?LessonModule $lessonModule = null,
  1859.         ?bool $required = false, 
  1860.         ?bool $filterModule = false
  1861.     )
  1862.     {
  1863.         $query = $this->createQueryBuilder('l');
  1864.         $query->select('COUNT(l.id) AS total');
  1865.         $query->innerJoin(
  1866.             'EADPlataforma:LessonModule', 
  1867.             'lm', 
  1868.             'WITH', 
  1869.             'lm.id = l.lessonModule AND lm.deleted = :deleted'
  1870.         );
  1872.         $query->innerJoin(
  1873.             'EADPlataforma:Course', 
  1874.             'c', 
  1875.             'WITH', 
  1876.             'c.id = l.course AND c.deleted = :deleted'
  1877.         );
  1879.         if($lessonModule){
  1880.             $query->andWhere('lm.order <= :lessonModuleOrder');
  1881.             $query->setParameter('lessonModuleOrder', $lessonModule->getOrder());
  1883.             if($filterModule){
  1884.                 $query->andWhere('lm.id = :lessonModule');
  1885.                 $query->setParameter('lessonModule', $lessonModule->getId());
  1886.             }
  1887.         }
  1889.         if($required){
  1890.             $query->andWhere('l.controlRequirement = :required');
  1891.             $query->setParameter('required', LessonEnum::YES);
  1892.         }
  1894.         $query->andWhere('l.deleted = :deleted');
  1895.         $query->andWhere('l.course = :courseId');
  1896.         $query->andWhere('l.status = :lessonStatus');
  1897.         $query->andWhere('lm.status = :lessonModuleStatus');
  1898.         
  1899.         $query->setParameter('courseId', $course->getId());
  1900.         $query->setParameter('deleted', LessonEnum::ITEM_NO_DELETED);
  1901.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  1902.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  1903.         $query->setMaxResults(1);
  1905.         $result = (object)$query->getQuery()->getOneOrNullResult();
  1906.         return $result->total;
  1907.     }
  1909.     public function countCourseLessons(
  1910.         Course $course,
  1911.         int $userId,
  1912.         ?LessonModule $lessonModule = null, 
  1913.         $isHistory = false
  1914.     )
  1915.     {
  1916.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  1918.         $permission = $userPermissionUtil->getPermission("course", "see");
  1919.         $user = $userPermissionUtil->getUser();
  1920.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  1921.             $course, 
  1922.             $user
  1923.         );
  1925.         $sqlDateConclusion = "
  1926.             SELECT
  1927.                 (
  1928.                     CASE 
  1929.                         WHEN ll.complete = :yes THEN ll.date_conclusion 
  1930.                         ELSE CURDATE() 
  1931.                     END
  1932.                 ) AS date_conclusion
  1933.             FROM lesson_log AS ll
  1934.             WHERE ll.lesson_id = l.id
  1935.             AND ll.course_id = l.course_id
  1936.             AND ll.user_id = :userId
  1937.             ORDER BY ll.id DESC
  1938.             LIMIT 1
  1939.         ";
  1941.         $sqlDateRegisterEnrollement = "
  1942.             SELECT
  1943.                 e.date_register
  1944.             FROM enrollment AS e
  1945.             WHERE e.deleted = :deletedEnrollment
  1946.             AND e.course_id = l.course_id
  1947.             AND e.user_id = :userId
  1948.             ORDER BY e.id DESC
  1949.             LIMIT 1
  1950.         ";
  1952.         $sql = "
  1953.             SELECT
  1954.                 COUNT(l.id) AS total
  1955.             FROM lesson AS l
  1956.             INNER JOIN course AS c ON (c.id = l.course_id AND c.deleted = :deletedCourse)
  1957.             INNER JOIN lesson_module AS lm ON (
  1958.                 lm.id = l.lesson_module_id AND lm.deleted = :deletedModule
  1959.             )
  1960.             LEFT JOIN library AS lb ON (lb.id = l.library_id AND lb.deleted = :deletedLibrary)
  1961.             WHERE l.deleted = :deleted
  1962.             AND l.course_id = :courseId
  1963.             /* AND  CASO FOSSE CONSIDERADA DATA DE LIBERAÇÃO DA AULA PARA ENCERRAR O ACESSO
  1964.             (
  1965.                 (
  1966.                     l.control_close_period = 0 OR 
  1967.                     l.control_close_period IS NULL
  1968.                 )
  1969.                 OR
  1970.                 (
  1971.                     l.control_close_period > 0
  1972.                     AND l.control_release_type = 0
  1973.                     AND DATEDIFF(CURDATE(), (DATE(
  1974.                         (
  1975.                             CASE 
  1976.                                 WHEN ({$sqlDateConclusion}) IS NOT NULL THEN ({$sqlDateConclusion})
  1977.                                 ELSE CURDATE()
  1978.                             END
  1979.                         )
  1980.                     ) + INTERVAL l.control_close_period DAY)) < 0
  1981.                 )
  1982.                 OR
  1983.                 (
  1984.                     l.control_close_period > 0
  1985.                     AND l.control_release_type = 1
  1986.                     AND DATEDIFF(CURDATE(), (DATE(
  1987.                         (l.control_date_release)
  1988.                     ) + INTERVAL l.control_close_period DAY)) < 0
  1989.                 )
  1990.                 OR
  1991.                 (
  1992.                     l.control_close_period > 0
  1993.                     AND l.control_release_type = 2
  1994.                     AND l.control_release_after_type = 1
  1995.                     AND DATEDIFF(CURDATE(), (DATE(
  1996.                         ({$sqlDateRegisterEnrollement})
  1997.                     ) + INTERVAL l.control_close_period DAY)) < 0
  1998.                 )
  1999.                 OR
  2000.                 (
  2001.                     l.control_close_period > 0
  2002.                     AND l.control_release_type = 2
  2003.                     AND l.control_release_after_type = 2
  2004.                 )
  2005.             )*/
  2006.         ";
  2009.         if($lessonModule){
  2010.             $sql .= " AND l.lesson_module_id = :lessonModuleId ";
  2011.         }
  2013.         if(
  2014.             $isHistory ||
  2015.             $userPermissionUtil->isLow($permission) || 
  2016.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2017.         ){
  2018.             $sql .= " AND l.status = :lessonStatus ";
  2019.             $sql .= " AND lm.status = :lessonModuleStatus ";
  2020.         }
  2022.         $stmt = $this->em->getConnection()->prepare($sql);
  2024.         //$stmt->bindValue(':deletedEnrollment', EnrollmentEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  2025.         $stmt->bindValue(':deletedCourse', CourseEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  2026.         $stmt->bindValue(':deletedModule', LessonModuleEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  2027.         $stmt->bindValue(':deletedLibrary', LibraryEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  2028.         $stmt->bindValue(':deleted', LessonEnum::ITEM_NO_DELETED, PDO::PARAM_INT);
  2029.         $stmt->bindValue(':courseId', $course->getId(), PDO::PARAM_INT);
  2030.         //$stmt->bindValue(':yes', LessonEnum::YES, PDO::PARAM_INT);
  2031.         //$stmt->bindValue(':userId', $userId, PDO::PARAM_INT);
  2033.         if($lessonModule){
  2034.             $stmt->bindValue(':lessonModuleId', $lessonModule->getId(), PDO::PARAM_INT);
  2035.         }
  2037.         if(
  2038.             $isHistory ||
  2039.             $userPermissionUtil->isLow($permission) ||
  2040.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2041.         ){
  2042.             $stmt->bindValue(':lessonStatus', LessonEnum::PUBLISHED, PDO::PARAM_INT);
  2043.             $stmt->bindValue(':lessonModuleStatus', LessonModuleEnum::PUBLISHED, PDO::PARAM_INT);
  2044.         }
  2045.         
  2046.         $stmt->execute();
  2048.         $result = $stmt->fetchAll(PDO::FETCH_CLASS);
  2050.         return $result[0]->total;
  2051.     }
  2053.     public function getCourseLessons(
  2054.         Course $course, 
  2055.         ?LessonModule $lessonModule = null, 
  2056.         ?array $lessonIds = null, 
  2057.         ?string $searchText = null
  2058.     )
  2059.     {
  2060.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2062.         $permission = $userPermissionUtil->getPermission("course", "see");
  2063.         $user = $userPermissionUtil->getUser();
  2064.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  2065.             $course, 
  2066.             $user
  2067.         );
  2068.         
  2069.         $query = $this->createQueryBuilder('l');
  2070.         $query->innerJoin(
  2071.             'EADPlataforma:LessonModule', 
  2072.             'lm', 
  2073.             'WITH', 
  2074.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2075.         );
  2077.         $query->innerJoin(
  2078.             'EADPlataforma:Course', 
  2079.             'c', 
  2080.             'WITH', 
  2081.             'c.id = l.course AND c.deleted = 0'
  2082.         );
  2084.         $query->leftJoin(
  2085.             'EADPlataforma:Library', 
  2086.             'lb', 
  2087.             'WITH', 
  2088.             'lb.id = l.library AND lb.deleted = 0'
  2089.         );
  2091.         $query->andWhere('l.deleted = 0');
  2092.         $query->andWhere('l.course = :courseId');
  2093.         $query->setParameter('courseId', $course->getId());
  2095.         if(!empty($searchText)){
  2096.             $query->andWhere('(l.title LIKE :searchText OR lm.title LIKE :searchText)');
  2097.             $query->setParameter('searchText', "%{$searchText}%");
  2098.         }
  2100.         if($lessonModule){
  2101.             $query->andWhere('l.lessonModule = :lessonModuleId');
  2102.             $query->setParameter('lessonModuleId', $lessonModule->getId());
  2103.         }
  2105.         if(is_array($lessonIds) && !empty($lessonIds)){
  2106.             $query->andWhere($query->expr()->in('l.id', $lessonIds));
  2107.         }
  2109.         if(
  2110.             $userPermissionUtil->isLow($permission) || 
  2111.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2112.         ){
  2113.             $query->andWhere('l.status = :lessonStatus');
  2114.             $query->andWhere('lm.status = :lessonModuleStatus');
  2115.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2116.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2117.         }
  2119.         $query->addOrderBy('l.order', 'ASC');
  2120.         $query->addOrderBy('l.lessonModule', 'ASC');
  2122.         $data = $query->getQuery()->execute();
  2124.         return $data;
  2125.     }
  2127.     public function getFirstLesson(Course $course, ?LessonModule $lessonModule = null)
  2128.     {
  2129.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2131.         $permission = $userPermissionUtil->getPermission("course", "see");
  2132.         $user = $userPermissionUtil->getUser();
  2134.         $courseTeamRepository = $this->em->getRepository(CourseTeam::class);
  2135.         $isInTeam = $courseTeamRepository->userExistInCourseTeam($course, $user);
  2136.         
  2137.         $query = $this->createQueryBuilder('l');
  2138.         $query->innerJoin(
  2139.             'EADPlataforma:LessonModule', 
  2140.             'lm', 
  2141.             'WITH', 
  2142.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2143.         );
  2145.         $query->innerJoin(
  2146.             'EADPlataforma:Course', 
  2147.             'c', 
  2148.             'WITH', 
  2149.             'c.id = l.course AND c.deleted = 0'
  2150.         );
  2152.         $query->andWhere('l.deleted = 0');
  2153.         $query->andWhere('l.course = :courseId');
  2154.         $query->setParameter('courseId', $course->getId());
  2156.         if($lessonModule){
  2157.             $query->andWhere('l.lessonModule = :lessonModuleId');
  2158.             $query->setParameter('lessonModuleId', $lessonModule->getId());
  2159.         }
  2161.         if(
  2162.             $userPermissionUtil->isLow($permission) || 
  2163.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2164.         ){
  2165.             $query->andWhere('l.status = :lessonStatus');
  2166.             $query->andWhere('lm.status = :lessonModuleStatus');
  2167.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2168.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2169.         }
  2171.         $query->addOrderBy('lm.order', 'ASC');
  2172.         $query->addOrderBy('l.order', 'ASC');
  2174.         $query->setMaxResults(1);
  2176.         return $query->getQuery()->getOneOrNullResult();
  2177.     }
  2179.     public function getLastLesson(Course $course, ?LessonModule $lessonModule = null)
  2180.     {
  2181.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2183.         $permission = $userPermissionUtil->getPermission("course", "see");
  2184.         $user = $userPermissionUtil->getUser();
  2185.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  2186.             $course, 
  2187.             $user
  2188.         );
  2189.         
  2190.         $query = $this->createQueryBuilder('l');
  2191.         $query->innerJoin(
  2192.             'EADPlataforma:LessonModule', 
  2193.             'lm', 
  2194.             'WITH', 
  2195.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2196.         );
  2198.         $query->innerJoin(
  2199.             'EADPlataforma:Course', 
  2200.             'c', 
  2201.             'WITH', 
  2202.             'c.id = l.course AND c.deleted = 0'
  2203.         );
  2205.         $query->andWhere('l.deleted = 0');
  2206.         $query->andWhere('l.course = :courseId');
  2207.         $query->setParameter('courseId', $course->getId());
  2209.         if($lessonModule){
  2210.             $query->andWhere('l.lessonModule = :lessonModuleId');
  2211.             $query->setParameter('lessonModuleId', $lessonModule->getId());
  2212.         }
  2214.         if(
  2215.             $userPermissionUtil->isLow($permission) || 
  2216.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2217.         ){
  2218.             $query->andWhere('l.status = :lessonStatus');
  2219.             $query->andWhere('lm.status = :lessonModuleStatus');
  2220.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2221.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2222.         }
  2224.         $query->addOrderBy('lm.order', 'DESC');
  2225.         $query->addOrderBy('l.order', 'DESC');
  2227.         $query->setMaxResults(1);
  2229.         return $query->getQuery()->getOneOrNullResult();
  2230.     }
  2232.     public function getLessonByLessonModule(LessonModule $lessonModule)
  2233.     {   
  2235.         $query = $this->createQueryBuilder('l');
  2236.         $query->leftJoin(
  2237.             'EADPlataforma:Library', 
  2238.             'li', 
  2239.             'WITH', 
  2240.             'li.id = l.library AND li.deleted = 0'
  2241.         );
  2243.         $query->andWhere('l.deleted = 0');
  2244.         $query->andWhere('l.status = :status');
  2245.         $query->andWhere('l.course = :courseId');
  2246.         $query->andWhere('l.lessonModule = :lessonModule');
  2247.         $query->setParameter('courseId', $lessonModule->getCourse()->getId());
  2248.         $query->setParameter('lessonModule', $lessonModule->getId());
  2249.         $query->setParameter('status', LessonEnum::PUBLISHED);
  2251.         $query->addOrderBy('l.order', 'ASC');
  2253.         return $query->getQuery()->execute();
  2254.     }
  2256.     public function getNextLessonByLessonModule(
  2257.         int $order, 
  2258.         LessonModule $lessonModule, 
  2259.         int $limit = 3
  2260.     )
  2261.     {   
  2263.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2264.         $permission = $userPermissionUtil->getPermission("course", "see");
  2266.         $course = $lessonModule->getCourse();
  2267.         $user = $userPermissionUtil->getUser();
  2270.         $isInTeam = $this->em->getRepository(CourseTeam::class)->userExistInCourseTeam(
  2271.             $course, 
  2272.             $user
  2273.         );
  2275.         $query = $this->createQueryBuilder('l');
  2277.         $query->select('
  2278.             l.id,
  2279.             l.order,
  2280.             l.title,
  2281.             l.status,
  2282.             l.controlRequirement,
  2283.             l.controlReleaseType,
  2284.             l.controlReleaseAfterType,
  2285.             l.controlDateRelease,
  2286.             l.controlReleasePeriod,
  2287.             l.controlClosePeriod,
  2288.             lm.id AS lessonModule,
  2289.             li.type AS libraryType,
  2290.             li.pagesNumber,
  2291.             li.duration
  2292.         ');
  2294.         $query->innerJoin(
  2295.             'EADPlataforma:LessonModule', 
  2296.             'lm', 
  2297.             'WITH', 
  2298.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2299.         );
  2301.         $query->innerJoin(
  2302.             'EADPlataforma:Course', 
  2303.             'c', 
  2304.             'WITH', 
  2305.             'c.id = l.course AND c.deleted = 0'
  2306.         );
  2308.         $query->leftJoin(
  2309.             'EADPlataforma:Library', 
  2310.             'li', 
  2311.             'WITH', 
  2312.             'li.id = l.library AND li.deleted = 0'
  2313.         );
  2315.         if(
  2316.             $userPermissionUtil->isLow($permission) || 
  2317.             ($userPermissionUtil->isMiddle($permission) && !$isInTeam)
  2318.         ){
  2319.             $query->andWhere('l.status = :lessonStatus');
  2320.             $query->andWhere('lm.status = :lessonModuleStatus');
  2321.             $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2322.             $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2323.         }
  2325.         $query->andWhere('l.deleted = 0');
  2326.         $query->andWhere('l.course = :courseId');
  2327.         $query->andWhere('l.lessonModule = :lessonModule');
  2328.         $query->andWhere('l.order > :order');
  2330.         $query->setParameter('courseId', $course->getId());
  2331.         $query->setParameter('lessonModule', $lessonModule->getId());
  2332.         $query->setParameter('order', $order);
  2334.         $query->addOrderBy('l.order', 'ASC');
  2336.         $query->setMaxResults($limit);
  2338.         return $query->getQuery()->execute();
  2339.     }
  2341.     public function getLessonNotView($userId, $courseId, $lessonId = null)
  2342.     {
  2343.         $and = '';
  2345.         if(!empty($lessonId))
  2346.         {
  2347.             $and .= " AND l.id = :lessonId";
  2348.         }
  2350.         if(empty($courseId) || empty($userId))
  2351.         {
  2352.             return [];
  2353.         }
  2355.         $dql = "SELECT
  2356.                     l.id,
  2357.                     l.title,
  2358.                     lm.title AS titleModule,
  2359.                     '0' AS totalView,
  2360.                     '' AS lastAccess,
  2361.                     '--' AS timeWatch,
  2362.                     '0' AS completed,
  2363.                     '---' AS dateConclusion
  2364.                 FROM EADPlataforma:Lesson AS l
  2365.                 INNER JOIN EADPlataforma:LessonModule AS lm WITH (lm.id = l.lessonModule AND lm.deleted = 0)
  2366.                 WHERE l.deleted = 0
  2367.                 AND l.course = :courseId
  2368.                 {$and}
  2369.                 AND l.id NOT IN (
  2370.                     SELECT
  2371.                         IDENTITY (ll.lesson)
  2372.                     FROM EADPlataforma:LessonLogOrigin AS ll
  2373.                     WHERE ll.user != 1
  2374.                     AND ll.user = :userId
  2375.                     AND ll.course = :courseId
  2376.                 )
  2377.                 ORDER BY l.order ASC";
  2378.                 
  2379.         $query = $this->em->createQuery($dql);
  2380.         $query->setParameter('userId', $userId);
  2381.         $query->setParameter('courseId', $courseId);
  2382.       
  2383.         if(!empty($lessonId))
  2384.         {
  2385.             $query->setParameter('lessonId', $lessonId);
  2386.         }
  2388.         $data = $query->execute();
  2389.         
  2390.         $result = [];
  2391.         foreach ($data as $key => $value) {
  2392.             $result[] = [
  2393.                 $value["id"],
  2394.                 $value["title"],
  2395.                 $value["titleModule"],
  2396.                 $value["totalView"],
  2397.                 $value["lastAccess"],
  2398.                 $value["timeWatch"],
  2399.                 $value["completed"],
  2400.                 $value["dateConclusion"]
  2401.             ];
  2402.         }
  2404.         return $result;
  2405.     }
  2407.     public function isFirstCourseLesson(?Lesson $lesson)
  2408.     {
  2409.         if(!$lesson){
  2410.             return false;
  2411.         }
  2413.         $firstLesson = $this->getFirstLesson($lesson->getCourse());
  2414.         if($firstLesson){
  2415.             return $firstLesson->getId() == $lesson->getId();
  2416.         }
  2417.         return true;
  2418.     }
  2420.     public function isFirstModuleLesson(?Lesson $lesson)
  2421.     {
  2422.         if(!$lesson){
  2423.             return false;
  2424.         }
  2426.         $firstLesson = $this->getFirstLesson($lesson->getCourse(), $lesson->getLessonModule());
  2427.         if($firstLesson){
  2428.             return $firstLesson->getId() == $lesson->getId();
  2429.         }
  2430.         return true;
  2431.     }
  2433.     public function isLastCourseLesson(?Lesson $lesson)
  2434.     {
  2435.         if(!$lesson){
  2436.             return false;
  2437.         }
  2439.         $firstLesson = $this->getLastLesson($lesson->getCourse());
  2440.         if($firstLesson){
  2441.             return $firstLesson->getId() == $lesson->getId();
  2442.         }
  2443.         return true;
  2444.     }
  2446.     public function isLastModuleLesson(?Lesson $lesson)
  2447.     {
  2448.         if(!$lesson){
  2449.             return false;
  2450.         }
  2452.         $firstLesson = $this->getLastLesson(
  2453.             $lesson->getCourse(), 
  2454.             $lesson->getLessonModule()
  2455.         );
  2457.         if($firstLesson){
  2458.             return $firstLesson->getId() == $lesson->getId();
  2459.         }
  2460.         return true;
  2461.     }
  2463.     public function isLessonVisibleToStudent(
  2464.         Lesson $lesson, 
  2465.         ?bool $ignoreControlFunction = false,
  2466.         ?bool $isStudent = true
  2467.     ): bool
  2468.     {
  2469.         $info = $this->checkLessonVisibleToStudent($lesson, $ignoreControlFunction, $isStudent);
  2471.         return $info->visible;
  2472.     }
  2474.     public function checkLessonVisibleToStudent(
  2475.         Lesson $lesson, 
  2476.         ?bool $ignoreControlFunction = false,
  2477.         ?bool $isStudent = true
  2478.     ): object
  2479.     {
  2481.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2482.         $user = $userPermissionUtil->getUser();
  2484.         $info = (object)[
  2485.             "visible" => true,
  2486.             "message" => "",
  2487.         ];
  2489.         if(!$user){
  2491.             $info->visible = false;
  2493.             return $info;
  2494.         }
  2496.         $course = $lesson->getCourse();
  2497.         $lessonModule = $lesson->getLessonModule();
  2499.         if($lesson->isDeleted() || $lessonModule->isDeleted() || $course->isDeleted()){
  2500.             $info->visible = false;
  2502.             return $info;
  2503.         }
  2505.         if(!$isStudent){
  2507.             $info->visible = true;
  2509.             return $info;
  2510.         }
  2512.         $enrollmentRepository = $this->em->getRepository(Enrollment::class);
  2513.         $isEnroll = $enrollmentRepository->isValidEnrollmentByUser(
  2514.             $user->getId(), 
  2515.             $course->getId()
  2516.         );
  2518.         $hasLessonControl = $this->configuration->checkModuleIsAbleOnPlan(
  2519.             'lessonControlFunction'
  2520.         );
  2522.             
  2523.         if($lesson->getStatus() == LessonEnum::DRAFT){
  2524.             $info->visible = false;
  2526.             return $info;
  2527.         }
  2529.         if($lessonModule->getStatus() == LessonModuleEnum::DRAFT){
  2530.             $info->visible = false;
  2532.             return $info;
  2533.         }
  2535.         if($course->getStatus() == CourseEnum::DRAFT){
  2536.             $info->visible = false;
  2538.             return $info;
  2539.         }
  2541.         if(!$isEnroll){
  2542.             $info->visible = false;
  2544.             return $info;
  2545.         }
  2546.         
  2547.         if(!$ignoreControlFunction){
  2548.             if($lesson->getControlReleaseType() == LessonEnum::FIXED_DATE){
  2549.                 $todaySeconds = strtotime(date('Y-m-d H:i:s'));
  2550.                 if($hasLessonControl){
  2551.                     $controlClosePeriod = $lesson->getControlClosePeriod();
  2552.                     if(!empty($controlClosePeriod)){
  2553.                         $timeLog = strtotime(
  2554.                             "{$lesson->getControlDateRelease()} + {$controlClosePeriod} day"
  2555.                         );
  2557.                         if($todaySeconds > $timeLog){
  2558.                             $info->visible = false;
  2560.                             return $info;
  2561.                         }
  2562.                     }
  2563.                 }
  2564.             }else{
  2565.                 $lessonLogRepository = $this->emEadmin->getRepository(LessonLog::class);
  2566.                 $logId = "{$course->getId()}#{$user->getId()}#{$lesson->getId()}";
  2567.                 $lessonLog = $lessonLogRepository->find($logId);
  2569.                 //check lesson to user is closed
  2570.                 if($lessonLog){
  2571.                     $todaySeconds = strtotime(date('Y-m-d H:i:s'));
  2572.                     if($hasLessonControl){
  2573.                         $controlClosePeriod = $lesson->getControlClosePeriod();
  2574.                         if(
  2575.                             !empty($controlClosePeriod) && 
  2576.                             $lessonLog->getComplete() == LessonEnum::YES
  2577.                         ){
  2578.                             $timeLog = strtotime(
  2579.                                 "{$lessonLog->getDateConclusion()} + {$controlClosePeriod} day"
  2580.                             );
  2582.                             if($todaySeconds > $timeLog){
  2583.                                 $info->visible = false;
  2585.                                 return $info;
  2586.                             }
  2587.                         }
  2588.                     }
  2589.                 }
  2590.             } 
  2591.         }
  2593.         return $info;
  2594.     }
  2596.     public function getLessonNumberByProduct(Product $product)
  2597.     {
  2598.         $query = $this->createQueryBuilder('l');
  2599.         $query->select("COUNT(l.id) AS total");
  2600.         $query->innerJoin('EADPlataforma:Course', 'c', 'WITH', 'l.course = c.id');
  2601.         $query->innerJoin('EADPlataforma:Product', 'p', 'WITH', 'l.course MEMBER OF p.course');
  2602.         $query->innerJoin('EADPlataforma:LessonModule', 'lm', 'WITH', 'l.lessonModule = lm.id');
  2604.         $query->andWhere('l.deleted = :deletedLesson');
  2605.         $query->andWhere('c.deleted = :deletedCourse');
  2606.         $query->andWhere('lm.deleted = :deletedLessonModule');
  2608.         $query->andWhere('l.status = :statusLesson');
  2609.         $query->andWhere('c.status = :statusCourse');
  2610.         $query->andWhere('lm.status = :statusLessonModule');
  2612.         $query->andWhere('p.id = :productId');
  2614.         $query->setParameter('deletedLesson', LessonEnum::ITEM_NO_DELETED);
  2615.         $query->setParameter('deletedCourse', CourseEnum::ITEM_NO_DELETED);
  2616.         $query->setParameter('deletedLessonModule', LessonModuleEnum::ITEM_NO_DELETED);
  2618.         $query->setParameter('statusLesson', LessonEnum::PUBLISHED);
  2619.         $query->setParameter('statusCourse', CourseEnum::PUBLISHED);
  2620.         $query->setParameter('statusLessonModule', LessonModuleEnum::PUBLISHED);
  2622.         $query->setParameter('productId', $product->getId());
  2624.         $result = (object)$query->getQuery()->getOneOrNullResult();
  2625.         return $result->total;
  2626.     }
  2628.     public function getLessonForExportPresence(Course $course, $lessonModuleId = null){
  2629.         $query = $this->createQueryBuilder('l');
  2631.         $query->select('
  2632.             l.id,
  2633.             lm.id AS lessonModuleId,
  2634.             l.order,
  2635.             lm.title,
  2636.             l.title AS lessonTitle
  2637.         ');
  2639.         $query->innerJoin(
  2640.             'EADPlataforma:LessonModule', 
  2641.             'lm', 
  2642.             'WITH', 
  2643.             'lm.id = l.lessonModule AND lm.deleted = 0'
  2644.         );
  2646.         if($lessonModuleId){
  2647.             $query->andWhere('lm.id = :lessonModuleId');
  2648.             $query->setParameter('lessonModuleId', $lessonModuleId);
  2649.         }
  2650.         
  2651.         $query->andWhere('l.status = :lessonStatus');
  2652.         $query->andWhere('lm.status = :lessonModuleStatus');
  2653.         $query->setParameter('lessonStatus', LessonEnum::PUBLISHED);
  2654.         $query->setParameter('lessonModuleStatus', LessonModuleEnum::PUBLISHED);
  2655.         
  2656.         $query->andWhere('l.deleted = 0');
  2657.         $query->andWhere('l.course = :courseId');
  2659.         $query->setParameter('courseId', $course->getId());
  2661.         $query->addOrderBy('lm.order', 'ASC');
  2662.         $query->addOrderBy('lm.id', 'ASC');
  2663.         $query->addOrderBy('l.order', 'ASC');
  2664.         $query->addOrderBy('l.id', 'ASC');
  2666.         return $query->getQuery()->execute();
  2667.     }
  2669.     public function restore(Lesson $lesson, $typeItem, $key)
  2670.     {
  2671.         $lessonId = $lesson->getId();
  2672.         $dateNow = date('Y-m-d H:i:s');
  2674.         $lastOrder = $this->count(
  2675.             [ 
  2676.                 "deleted" => LessonEnum::ITEM_NO_DELETED, 
  2677.                 "lessonModule" => $lesson->getLessonModule()->getId() 
  2678.             ]
  2679.         ) + ($key + 1);
  2681.         $lesson->setOrder($lastOrder);
  2683.         $courseRepository =  $this->em->getRepository(Course::class);
  2685.         $lesson->setUserDelete($this->getUser());
  2686.         $lesson->setDateDelete($dateNow);
  2687.         $lesson->restore();
  2688.         $deleted = LessonEnum::ITEM_NO_DELETED;
  2689.         $typeDelete = LessonEnum::CASCADE;
  2691.         $this->em->getRepository(Exam::class)->restoreByLesson(
  2692.             $lessonId, 
  2693.             $deleted, 
  2694.             $typeDelete, 
  2695.             $this->getUser(), 
  2696.             $dateNow
  2697.         );
  2699.         $this->em->getRepository(ExamUser::class)->restoreByLesson(
  2700.             $lessonId, 
  2701.             $deleted, 
  2702.             $typeDelete, 
  2703.             $this->getUser(), 
  2704.             $dateNow
  2705.         );
  2707.         $this->em->getRepository(LessonSupport::class)->restoreByLesson(
  2708.             $lessonId, 
  2709.             $deleted, 
  2710.             $typeDelete, 
  2711.             $this->getUser(), 
  2712.             $dateNow
  2713.         );
  2715.         $this->em->getRepository(LessonXLibrary::class)->restoreByLesson(
  2716.             $lessonId, 
  2717.             $deleted, 
  2718.             $typeDelete, 
  2719.             $this->getUser(), 
  2720.             $dateNow
  2721.         );
  2722.         $this->em->getRepository(Trash::class)->deleteTrash($lessonId, $typeItem);
  2723.     }
  2725.     public function delete(Lesson $lesson, $typeItem, $permission, $isTrash)
  2726.     {
  2727.         $lessonId = $lesson->getId();
  2728.         $dateNow = date('Y-m-d H:i:s');
  2729.         $typeDelete = LessonEnum::CASCADE;
  2731.         $notificationService = $this->generalService->getService('NotificationService');
  2732.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2734.         $lessonXLibrarys = $this->em->getRepository(LessonXLibrary::class)->findBy([
  2735.             "lesson" => $lesson->getId(),
  2736.         ]);
  2738.         $libraryRepository = $this->em->getRepository(Library::class);
  2739.         $libraryModule = $this->configuration->checkModuleIsAbleOnPlan('libraryModule');
  2741.         if($isTrash == LessonEnum::YES){
  2742.             $permission = $userPermissionUtil->getPermission("trash", "delete");
  2743.         }
  2745.         $isLessonTeacher = $this->isLessonTeacher($lesson, $this->getUser());
  2746.         if($isLessonTeacher || $userPermissionUtil->isHigh($permission)){
  2747.             $lesson->setUserDelete($this->getUser());
  2748.             $lesson->setDateDelete($dateNow);
  2749.             $lesson->individual();
  2750.             
  2751.             if($lesson->isOnTrash() || $lesson->isDeleted()){
  2752.                 
  2753.                 $lesson->delete();
  2754.                 $deleted = LessonEnum::ITEM_DELETED;
  2755.                 $this->em->getRepository(Trash::class)->deleteTrash($lessonId, $typeItem);
  2757.                 $this->em->flush();
  2759.                 foreach ($lessonXLibrarys as $key => $lessonXLibrary) {
  2760.                     $library = $lessonXLibrary->getLibrary();
  2761.                     if(!$libraryModule && $library){
  2762.                         $library->cascade();
  2763.                         $libraryRepository->deleteContent($library);
  2764.                     }
  2765.                     $lessonXLibrary->delete();
  2766.                 }
  2768.                 $library = $lesson->getLibrary();
  2770.                 if(!$libraryModule && $library){
  2771.                     $library->cascade();
  2772.                     $libraryRepository->deleteContent($library);
  2773.                 }
  2774.             }
  2776.             if(!$lesson->isOnTrash() && !$lesson->isDeleted()){
  2777.                 $order = $lesson->getOrder();
  2778.                 $this->refreshOrder(
  2779.                     $lesson->getCourse()->getId(), 
  2780.                     $lesson->getLessonModule()->getId(),
  2781.                     $order,
  2782.                     null,
  2783.                     true
  2784.                 );
  2786.                 $notificationService->delete(
  2787.                     NotificationEnum::ORIGIN_LESSON_SUPPORT_LIKE, 
  2788.                     $lessonId
  2789.                 );
  2791.                 $notificationService->delete(
  2792.                     NotificationEnum::ORIGIN_LESSON_SUPPORT_ANSWER_LIKE, 
  2793.                     $lessonId
  2794.                 );
  2795.                 $notificationService->delete(
  2796.                     NotificationEnum::ORIGIN_LESSON_SUPPORT_NEW, 
  2797.                     $lessonId
  2798.                 );
  2799.                 $notificationService->delete(
  2800.                     NotificationEnum::ORIGIN_LESSON_SUPPORT_ANSWER_NEW, 
  2801.                     $lessonId
  2802.                 );
  2803.                 $notificationService->delete(
  2804.                     NotificationEnum::ORIGIN_LESSON_NEW, 
  2805.                     $lessonId
  2806.                 );
  2807.                 $notificationService->delete(
  2808.                     NotificationEnum::ORIGIN_LESSON_CHANGE, 
  2809.                     $lessonId
  2810.                 );
  2812.                 $lesson->trash();
  2813.                 $deleted = LessonEnum::ITEM_ON_TRASH;
  2814.                 $this->em->getRepository(Trash::class)->insertTrash(
  2815.                     $lesson, 
  2816.                     $typeItem, 
  2817.                     "Aula: {$lesson->getTitle()} | Prof. {$lesson->getUser()->getName()}"
  2818.                 );
  2819.             }
  2820.         }
  2821.         
  2822.         $this->em->getRepository(Exam::class)->deleteByLesson(
  2823.             $lessonId, 
  2824.             $deleted, 
  2825.             $typeDelete, 
  2826.             $this->getUser(), 
  2827.             $dateNow
  2828.         );
  2830.         $this->em->getRepository(ExamUser::class)->deleteByLesson(
  2831.             $lessonId, 
  2832.             $deleted, 
  2833.             $typeDelete, 
  2834.             $this->getUser(), 
  2835.             $dateNow
  2836.         );
  2838.         $this->em->getRepository(LessonSupport::class)->deleteByLesson(
  2839.             $lessonId, 
  2840.             $deleted, 
  2841.             $typeDelete, 
  2842.             $this->getUser(), 
  2843.             $dateNow
  2844.         );
  2846.         $this->em->getRepository(LessonXLibrary::class)->deleteByLesson(
  2847.             $lessonId, 
  2848.             $deleted, 
  2849.             $typeDelete, 
  2850.             $this->getUser(), 
  2851.             $dateNow
  2852.         );
  2853.     }
  2855.     public function restoreByCourse($courseId, $deleted, $typeDelete){
  2857.         $typeItem = TrashEnum::LESSON;
  2859.         $lessons = $this->em->getRepository(Lesson::class)->findBy([
  2860.             "course" => $courseId,
  2861.             "deleted" => (1 - $deleted),
  2862.             "typeDelete" => $typeDelete
  2863.         ]);
  2865.         foreach ($lessons as $key => $lesson) {
  2866.             $this->restore($lesson, $typeItem, $key);
  2867.         }
  2868.     }
  2870.     public function deleteByCourse($courseId, $deleted){
  2872.         $typeItem = TrashEnum::LESSON;
  2873.         $isTrash = LessonEnum::NO;
  2875.         if($deleted == LessonEnum::ITEM_ON_TRASH){
  2876.             $isTrash = LessonEnum::YES;
  2877.         }
  2879.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2880.         $permission = $userPermissionUtil->getPermission(
  2881.             "course", 
  2882.             "lesson", 
  2883.             "delete"
  2884.         );
  2886.         $lessons = $this->em->getRepository(Lesson::class)->findBy([
  2887.             "course" => $courseId,
  2888.             "deleted" => ($deleted - 1)
  2889.         ]);
  2891.         foreach ($lessons as $key => $lesson) {
  2892.             $this->delete($lesson, $typeItem, $permission, $isTrash);
  2893.             $lesson->cascade();
  2894.         }
  2895.     }
  2897.     public function restoreByLessonModule($lessonModuleId, $deleted, $typeDelete){
  2899.         $typeItem = TrashEnum::LESSON;
  2901.         $lessons = $this->em->getRepository(Lesson::class)->findBy([
  2902.             "lessonModule" => $lessonModuleId,
  2903.             "deleted" => (1 - $deleted),
  2904.             "typeDelete" => $typeDelete
  2905.         ]);
  2907.         foreach ($lessons as $key => $lesson) {
  2908.             $this->restore($lesson, $typeItem, $key);
  2909.         }
  2910.     }
  2912.     public function deleteByLessonModule($lessonModuleId, $deleted){
  2914.         $typeItem = TrashEnum::LESSON;
  2915.         $isTrash = LessonEnum::NO;
  2917.         if($deleted == LessonEnum::ITEM_ON_TRASH){
  2918.             $isTrash = LessonEnum::YES;
  2919.         }
  2921.         $userPermissionUtil = $this->generalService->getUtil('UserPermissionUtil');
  2922.         $permission = $userPermissionUtil->getPermission(
  2923.             "course", 
  2924.             "lesson", 
  2925.             "delete"
  2926.         );
  2928.         $lessons = $this->em->getRepository(Lesson::class)->findBy([
  2929.             "lessonModule" => $lessonModuleId,
  2930.             "deleted" => ($deleted - 1)
  2931.         ]);
  2933.         foreach ($lessons as $key => $lesson) {
  2934.             $this->delete($lesson, $typeItem, $permission, $isTrash);
  2935.             $lesson->cascade();
  2936.         }
  2937.     }
  2939.     public function deleteTrashCron()
  2940.     {
  2941.         $sql = "UPDATE EADPlataforma:Lesson AS l SET l.deleted = 2 
  2942.                 WHERE l.dateDelete <= :date AND l.deleted = 1 ";
  2943.         $query = $this->em->createQuery($sql);
  2944.         $query->setParameter('date', date('Y-m-d H:i:s', strtotime('-90 days')));
  2945.         $query->execute();
  2946.     }
  2947. }