WebSVN – LeadersLinked - Backend – Diff – /module/LeadersLinked/src/Controller/MicrolearningAccessForStudentsController.php

 use Laminas\Db\ResultSet\HydratingResultSet;
 use Laminas\Paginator\Adapter\DbSelect;
 use Laminas\Paginator\Paginator;
 use Laminas\Mvc\I18n\Translator;
 use LeadersLinked\Mapper\MicrolearningTopicMapper;
-use LeadersLinked\Mapper\MicrolearningCapsuleMapper;
-use LeadersLinked\Mapper\MicrolearningTopicCapsuleMapper;
-use LeadersLinked\Mapper\MicrolearningCapsuleUserMapper;
 use LeadersLinked\Mapper\MicrolearningUserMapper;
 use LeadersLinked\Mapper\UserMapper;
 use LeadersLinked\Mapper\QueryMapper;
 use LeadersLinked\Mapper\ApplicationMapper;
 use LeadersLinked\Mapper\PushMapper;
 use LeadersLinked\Mapper\MicrolearningExtendUserProgramMapper;
 use LeadersLinked\Mapper\MicrolearningExtendUserPartnerMapper;
 use LeadersLinked\Mapper\MicrolearningExtendUserSectorMapper;
 use LeadersLinked\Mapper\MicrolearningExtendUserStudentTypeMapper;
 use LeadersLinked\Mapper\MicrolearningExtendUserCountryMapper;
-use LeadersLinked\Model\MicrolearningCapsuleUser;
 use LeadersLinked\Model\MicrolearningUser;
 use LeadersLinked\Model\Push;
 use LeadersLinked\Model\Application;
 use LeadersLinked\Model\Notification;
 use LeadersLinked\Model\Network;
 use LeadersLinked\Model\MicrolearningExtendUserProgram;
 use LeadersLinked\Model\MicrolearningExtendUserPartner;
 use LeadersLinked\Model\MicrolearningExtendUserSector;
 use LeadersLinked\Model\MicrolearningExtendUserStudentType;
 use LeadersLinked\Model\MicrolearningExtendUserCountry;
-use LeadersLinked\Form\Microlearning\TopicCapsuleForm;
+use LeadersLinked\Form\Microlearning\TopicUserForm;
 use LeadersLinked\Form\Microlearning\PushMicrolearningNotificationForm;
-use LeadersLinked\Form\Microlearning\CapsuleCustomerUploadForm;
+use LeadersLinked\Form\Microlearning\TopicCustomerUploadForm;
 use LeadersLinked\Library\Functions;
 use LeadersLinked\Cache\CacheInterface;
 use LeadersLinked\Cache\CacheImpl;
 use PhpOffice\PhpSpreadsheet\IOFactory;
+use LeadersLinked\Mapper\MicrolearningTopicUserMapper;
+use LeadersLinked\Model\MicrolearningTopicUser;
 class MicrolearningAccessForStudentsController extends AbstractActionController
+{
     /**
+                }
                 if($isJson) {
                     try {
-                        $topic_uuid     = Functions::sanitizeFilterString($request->getQuery('topic_uuid'));
-                        $capsule_uuid   = Functions::sanitizeFilterString($request->getQuery('capsule_uuid'));
+                        $topic_uuid     = Functions::sanitizeFilterString($request->getQuery('topic_uuid'));
                         $data = [
                             'link_upload' => '',
-                            'items' => [] ,
-                            'total' => 0,
+                            'items' => [] ,
-                            'capsules' => []
+                            'total' => 0,
                         ];
                             return new JsonModel([
                                 'success' => true,
                                 'data' => 'ERROR_UNAUTHORIZED'
                             ]);
+                        }
-                        if(!$capsule_uuid) {
-                            $topicCapsuleMapper = MicrolearningTopicCapsuleMapper::getInstance($this->adapter);
-                            $records = $topicCapsuleMapper->fetchAllByTopicId($topic->id);
-                            $capsules = [];
-                            foreach($records as $record)
-                            {
-                                $capsuleMapper = MicrolearningCapsuleMapper::getInstance($this->adapter);
-                                $capsule = $capsuleMapper->fetchOneById($record->capsule_id);
-                                $capsules[$capsule->uuid] = $capsule->name;
-                            }
-                            $data['capsules']  = $capsules;
-                        }
-                        if(!$capsule_uuid) {
-                            return new JsonModel([
-                                'success' => true,
-                                'data' => $data
-                            ]);
-                        }
-                        $capsuleMapper = MicrolearningCapsuleMapper::getInstance($this->adapter);
-                        $capsule = $capsuleMapper->fetchOneByUuid($capsule_uuid);
-                        if(!$capsule) {
-                            return new JsonModel([
-                                'success' => true,
-                                'data' => 'ERROR_CAPSULE_NOT_FOUND'
-                            ]);
-                        }
-                        $data['link_upload'] = $this->url()->fromRoute('microlearning/access-for-students/upload',['topic_uuid' => $topic->uuid, 'capsule_uuid' => $capsule->uuid]);
+                        $data['link_upload'] = $this->url()->fromRoute('microlearning/access-for-students/upload',['topic_uuid' => $topic->uuid]);
-                        $data['link_notification'] = $this->url()->fromRoute('microlearning/access-for-students/notification',['topic_uuid' => $topic->uuid, 'capsule_uuid' => $capsule->uuid]);
+                        $data['link_notification'] = $this->url()->fromRoute('microlearning/access-for-students/notification',['topic_uuid' => $topic->uuid]);
                         $search = $this->params()->fromQuery('search', []);
                         $queryMapper = QueryMapper::getInstance($this->adapter);
                         $sql = $queryMapper->getSql();
                         $select = $sql->select();
                         $select->columns(['access', 'paid_from', 'paid_to', 'added_on', 'updated_on']);
-                        $select->from(['tb1' => MicrolearningCapsuleUserMapper::_TABLE] );
+                        $select->from(['tb1' => MicrolearningTopicUserMapper::_TABLE] );
                         $select->join(['tb2' => UserMapper::_TABLE], 'tb1.user_id = tb2.id', ['uuid', 'first_name', 'last_name', 'email']);
-                        $select->where->equalTo('tb1.company_id', $capsule->company_id);
+                        $select->where->equalTo('tb1.company_id', $topic->company_id);
-                        $select->where->equalTo('tb1.topic_id', $topic->id);
-                        $select->where->equalTo('tb1.capsule_id', $capsule->id);
+                        $select->where->equalTo('tb1.topic_id', $topic->id);
                         if($search) {
                             $select->where->nest()
                         $records = $paginator->getCurrentItems();
                         foreach($records as $record)
+                        {
                             $params = [
                                 'topic_uuid' => $topic->uuid,
-                                'capsule_uuid' => $capsule->uuid,
                                 'user_uuid' => $record['uuid']
                             ];
                             $actions = [];
                             switch($record['access'])
+                            {
-                                case MicrolearningCapsuleUser::ACCESS_UNLIMITED :
+                                case MicrolearningTopicUser::ACCESS_UNLIMITED :
                                     $actions['link_revoke'] = $allowRevoke ? $this->url()->fromRoute('microlearning/access-for-students/revoke', $params) : '';
                                     $details['access'] = 'LABEL_UNLIMIT';
                                     break;
-                                case MicrolearningCapsuleUser::ACCESS_REVOKE :
+                                case MicrolearningTopicUser::ACCESS_REVOKE :
                                     $actions['link_unlimit'] = $allowUnlimit ? $this->url()->fromRoute('microlearning/access-for-students/unlimit', $params) : '';
                                     $details['access'] = 'LABEL_REVOKED';
                                     break;
-                                case MicrolearningCapsuleUser::ACCESS_PAY_PERIOD :
+                                case MicrolearningTopicUser::ACCESS_PAY_PERIOD :
                                     $actions['link_cancel'] = $allowCancel ? $this->url()->fromRoute('microlearning/access-for-students/cancel', $params) : '';
                                     $dt_paid_from = \DateTime::createFromFormat('Y-m-d', $record['paid_from']);
                                     $dt_paid_to = \DateTime::createFromFormat('Y-m-d', $record['paid_to']);
                                     $details['access'] = 'LABEL_PAY_PERIOD';
                                     $details['paid_from'] = $dt_paid_from->format('d/m/Y');
                                     $details['paid_to'] = $dt_paid_to->format('d/m/Y');
                                     break;
-                                case MicrolearningCapsuleUser::ACCESS_SUPENDED :
+                                case MicrolearningTopicUser::ACCESS_SUPENDED :
                                     $dt_paid_from = \DateTime::createFromFormat('Y-m-d', $record['paid_from']);
                                     $dt_paid_to = \DateTime::createFromFormat('Y-m-d', $record['paid_to']);
                         $topic_id = $topics[0]->id;
                     }  else {
                         $topic_id = 0;
+                    }
-                    $form = new TopicCapsuleForm($this->adapter, $currentCompany->id, $topic_id);
+                    $form = new TopicUserForm($this->adapter, $currentCompany->id, $topic_id);
                     $formPushNotification = new PushMicrolearningNotificationForm($this->adapter, $currentCompany->id);
-                    $formCapsuleCustomer = new CapsuleCustomerUploadForm();
                     $formTopicCustomer = new TopicCustomerUploadForm();
                     $this->layout()->setTemplate('layout/layout-backend');
                     $viewModel = new ViewModel();
                     $viewModel->setTemplate('leaders-linked/microlearning-access-for-students/index.phtml');
                     $viewModel->setVariables([
                         'form' => $form,
                         'formPushNotification' => $formPushNotification,
-                        'formCapsuleCustomer' => $formCapsuleCustomer
+                        'formTopicCustomer' => $formTopicCustomer
                     ]);
                 'success' => false,
                 'data' => $e->getMessage()
             ]);
+        }
+    }
+    /**
+     * Revokes unlimited access for a user to a specific microlearning topic
+     *
+     * This action handles the revocation of unlimited access privileges for a user.
+     * It checks various conditions before proceeding with the revocation:
+     * - Validates current user and company
+     * - Verifies topic and user existence
+     * - Ensures proper authorization
+     * - Confirms the user has unlimited access before revoking
+     *
+     * @return JsonModel Returns a JSON response indicating success or failure
+     */
     public function revokeAction()
+    {
+        // Get the current request object
         $request = $this->getRequest();
         // Get current user and company from plugin
         $currentUserPlugin = $this->plugin('currentUserPlugin');
         $currentUser    = $currentUserPlugin->getUser();
+        $currentCompany = $currentUserPlugin->getCompany();
         $currentCompany = $currentUserPlugin->getCompany();
         // Get topic and user UUIDs from route parameters
-        $request    = $this->getRequest();
-        $topic_uuid     = $this->params()->fromRoute('topic_uuid');
+        $request    = $this->getRequest();
-        $capsule_uuid   = $this->params()->fromRoute('capsule_uuid');
-        $user_uuid   = $this->params()->fromRoute('user_uuid');
+        $topic_uuid     = $this->params()->fromRoute('topic_uuid');
+        $user_uuid   = $this->params()->fromRoute('user_uuid');
-        $topicMapper = MicrolearningTopicMapper::getInstance($this->adapter);
-        $topic = $topicMapper->fetchOneByUuid($topic_uuid);
+        // Validate current user exists
-        if(!$topic) {
+        if(!$currentUser) {
             return new JsonModel([
                 'success'   => false,
-                'data'   => 'ERROR_TOPIC_NOT_FOUND'
+                'data'   => 'ERROR_UNAUTHORIZED'
-            ]);
-        }
+            ]);
+        }
         // Validate current company exists
-        if($topic->company_id != $currentCompany->id) {
+        if(!$currentCompany) {
             return new JsonModel([
                 'success'   => false,
                 'data'   => 'ERROR_UNAUTHORIZED'
             ]);
-        }
+        }
-        $capsuleMapper = MicrolearningCapsuleMapper::getInstance($this->adapter);
-        $capsule = $capsuleMapper->fetchOneByUuid($capsule_uuid);
+        // Validate topic UUID was provided
-        if(!$capsule) {
+        if(!$topic_uuid) {
             return new JsonModel([
+                'success'   => false,
+                'data'   => 'ERROR_TOPIC_NOT_FOUND'
+            ]);
+        }
+        // Validate user UUID was provided
+        if(!$user_uuid) {
+            return new JsonModel([
                 'success'   => false,
-                'data'   => 'ERROR_CAPSULE_NOT_FOUND'
+                'data'   => 'ERROR_USER_NOT_FOUND'
+            ]);
+        }
+        // Fetch topic by UUID and validate it exists
+        $topicMapper = MicrolearningTopicMapper::getInstance($this->adapter);
+        $topic = $topicMapper->fetchOneByUuid($topic_uuid);
+        if(!$topic) {
+            return new JsonModel([
+                'success'   => false,
+                'data'   => 'ERROR_TOPIC_NOT_FOUND'
             ]);
+        }
         // Validate topic belongs to current company
-        if($capsule->topic_id != $topic->id) {
+        if($topic->company_id != $currentCompany->id) {
             return new JsonModel([
+                'success'   => false,
-                'success'   => false,
+                'data'   => 'ERROR_UNAUTHORIZED'
-                'data'   => 'ERROR_UNAUTHORIZED'
+            ]);
             ]);
         // Fetch user by UUID and validate it exists
         $userMapper = UserMapper::getInstance($this->adapter);
         $user = $userMapper->fetchOneByUuid($user_uuid);
+        if(!$user) {
-        if(!$user) {
+            return new JsonModel([
-            return new JsonModel([
+                'success'   => false,
-                'success'   => false,
+                'data'   => 'ERROR_USER_NOT_FOUND'
-                'data'   => 'ERROR_USER_NOT_FOUND'
+            ]);
             ]);
         // Fetch topic-user relationship and validate it exists
-        $capsuleUserMapper = MicrolearningCapsuleUserMapper::getInstance($this->adapter);
+        $topicUserMapper = MicrolearningTopicUserMapper::getInstance($this->adapter);
+        $topicUser = $topicUserMapper->fetchOneByUserIdAndTopicId($user->id, $topic->id);
-        $capsuleUser = $capsuleUserMapper->fetchOneByUserIdAndCapsuleId($user->id, $capsule->id);
+        if(!$topicUser) {
-        if(!$capsuleUser) {
-            return new JsonModel([
+            return new JsonModel([
                 'success'   => false,
                 'data'   => 'ERROR_UNAUTHORIZED'
             ]);
+        }
-        if($request->isPost()) {
+        // Process revocation only for POST requests
+        if($request->isPost()) {
+            // Validate user has unlimited access before revoking
+            if($topicUser->access != MicrolearningTopicUser::ACCESS_UNLIMITED) {
+                return new JsonModel([
-            if($capsuleUser->access != MicrolearningCapsuleUser::ACCESS_UNLIMITED) {
+                    'success'   => false,
+                    'data'   => 'ERROR_USER_ACCESS_CANNT_BE_REVOKE'
-                return new JsonModel([
+                ]);
-                    'success'   => false,
+            }
-                    'data'   => 'ERROR_USER_ACCESS_CANNT_BE_REVOKE'
+            // Update access to revoked status
-                ]);
+            $topicUser->access = MicrolearningTopicUser::ACCESS_REVOKE;
             if($topicUserMapper->update($topicUser)) {
-            $capsuleUser->access = MicrolearningCapsuleUser::ACCESS_REVOKE;
+                // Refresh topic user data after update
-            if($capsuleUserMapper->update($capsuleUser)) {
                 $topicUser = $topicUserMapper->fetchOne($topicUser->id);
-                $capsuleUser = $capsuleUserMapper->fetchOne($capsuleUser->id);
+                if($topicUser) {
+                    // Update or create microlearning user record
-                if($capsuleUser) {
+                    $microlearningUserMapper = MicrolearningUserMapper::getInstance($this->adapter);
-                    $microlearningUserMapper = MicrolearningUserMapper::getInstance($this->adapter);
+                    $microlearningUser = $microlearningUserMapper->fetchOneByUserIdAndCompanyId($topicUser->user_id, $topicUser->company_id);
-                    $microlearningUser = $microlearningUserMapper->fetchOneByUserIdAndCompanyId($capsuleUser->user_id, $capsuleUser->company_id);
+                    if($microlearningUser) {
-                    if($microlearningUser) {
+                        // Update existing microlearning user
-                        $microlearningUser->updated_on = $capsuleUser->updated_on;
+                        $microlearningUser->updated_on = $topicUser->updated_on;
                         $microlearningUserMapper->update($microlearningUser);
                         $microlearningUserMapper->update($microlearningUser);
                     } else {
             } else {
                 return new JsonModel([
                     'success'   => false,
-                    'data'      => $capsuleUserMapper->getError()
+                    'data'      => $topicUserMapper->getError()
                 ]);
+            }
+        }
         // Return error for non-POST requests
         return new JsonModel([
             'success' => false,
             'data' => 'ERROR_METHOD_NOT_ALLOWED'
         ]);
+    }
-    }
+    public function unlimitAction()
-    public function unlimitAction()
+    {
-    {
+        try {
-        $request = $this->getRequest();
+            $request    = $this->getRequest();
-        $currentUserPlugin = $this->plugin('currentUserPlugin');
-        $currentUser    = $currentUserPlugin->getUser();
+            $currentUserPlugin = $this->plugin('currentUserPlugin');
-        $currentCompany = $currentUserPlugin->getCompany();
+            $currentUser    = $currentUserPlugin->getUser();
-        $request    = $this->getRequest();
-        $topic_uuid     = $this->params()->fromRoute('topic_uuid');
+            $currentCompany = $currentUserPlugin->getCompany();
-        $capsule_uuid   = $this->params()->fromRoute('capsule_uuid');
-        $user_uuid   = $this->params()->fromRoute('user_uuid');
+            $topic_uuid     = $this->params()->fromRoute('topic_uuid');
-        $topicMapper = MicrolearningTopicMapper::getInstance($this->adapter);
+            $user_uuid   = $this->params()->fromRoute('user_uuid');
-        $topic = $topicMapper->fetchOneByUuid($topic_uuid);
-        if(!$topic) {
+            if(!$currentUser) {
-            return new JsonModel([
+                return new JsonModel([
-                'success'   => false,
-                'data'   => 'ERROR_TOPIC_NOT_FOUND'
-            ]);
+                    'success'   => false,
-        }
+                    'data'   => 'ERROR_UNAUTHORIZED'
+                ]);
+            }
-        if($topic->company_id != $currentCompany->id) {
+            if(!$currentCompany) {
-            return new JsonModel([
+                return new JsonModel([
-                'success'   => false,
+                    'success'   => false,
-                'data'   => 'ERROR_UNAUTHORIZED'
-            ]);
-        }
+                    'data'   => 'ERROR_UNAUTHORIZED'
+                ]);
-        $capsuleMapper = MicrolearningCapsuleMapper::getInstance($this->adapter);
+            }
-        $capsule = $capsuleMapper->fetchOneByUuid($capsule_uuid);
-        if(!$capsule) {
+            if(!$topic_uuid) {
-            return new JsonModel([
+                return new JsonModel([
-                'success'   => false,
-                'data'   => 'ERROR_CAPSULE_NOT_FOUND'
+                    'success'   => false,
-            ]);
+                    'data'   => 'ERROR_TOPIC_NOT_FOUND'
-        }
+                ]);
+            }
-        if($capsule->topic_id != $topic->id) {
+            if(!$user_uuid) {
-            return new JsonModel([
+                return new JsonModel([
-                'success'   => false,
-                'data'   => 'ERROR_UNAUTHORIZED'
-            ]);
-        }
+                    'success'   => false,
+                    'data'   => 'ERROR_USER_NOT_FOUND'
-        $userMapper = UserMapper::getInstance($this->adapter);
+                ]);
-        $user = $userMapper->fetchOneByUuid($user_uuid);
+            }
-        if(!$user) {
+            if(!$request->isPost()) {
-            return new JsonModel([
+                return new JsonModel([
-                'success'   => false,
+                    'success'   => false,
-                'data'   => 'ERROR_USER_NOT_FOUND'
+                    'data'   => 'ERROR_METHOD_NOT_ALLOWED'
-            ]);
+                ]);
-        }
+            }
-        $capsuleUserMapper = MicrolearningCapsuleUserMapper::getInstance($this->adapter);
+            $topicMapper = MicrolearningTopicMapper::getInstance($this->adapter);
-        $capsuleUser = $capsuleUserMapper->fetchOneByUserIdAndCapsuleId($user->id, $capsule->id);
+            $topic = $topicMapper->fetchOneByUuid($topic_uuid);
-        if(!$capsuleUser) {
+            if(!$topic) {
-            return new JsonModel([
+                return new JsonModel([
+                    'success'   => false,
-                'success'   => false,
+                    'data'   => 'ERROR_TOPIC_NOT_FOUND'
+                ]);
+            }
+            if($topic->company_id != $currentCompany->id) {
+                return new JsonModel([
+                    'success'   => false,
-                'data'   => 'ERROR_UNAUTHORIZED'
+                    'data'   => 'ERROR_UNAUTHORIZED'
-            ]);
+                ]);
+            }
-        if($request->isPost()) {
+            $userMapper = UserMapper::getInstance($this->adapter);
             $user = $userMapper->fetchOneByUuid($user_uuid);
-            if($capsuleUser->access != MicrolearningCapsuleUser::ACCESS_REVOKE) {
-                return new JsonModel([
-                    'success'   => false,
-                    'data'   => 'ERROR_USER_ACCESS_CANNT_BE_UNLIMIT'
-                ]);
+            if(!$user) {
-            }
+                return new JsonModel([
-            $capsuleUser->access = MicrolearningCapsuleUser::ACCESS_UNLIMITED;
-            if($capsuleUserMapper->update($capsuleUser)) {
-                $capsuleUser = $capsuleUserMapper->fetchOne($capsuleUser->id);
-                if($capsuleUser) {
-                    $microlearningUserMapper = MicrolearningUserMapper::getInstance($this->adapter);
+                    'success'   => false,
-                    $microlearningUser = $microlearningUserMapper->fetchOneByUserIdAndCompanyId($capsuleUser->user_id, $capsuleUser->company_id);
-                    if($microlearningUser) {
-                        $microlearningUser->updated_on = $capsuleUser->updated_on;
-                        $microlearningUserMapper->update($microlearningUser);
-                    } else {
-                        $microlearningUser = new MicrolearningUser();
-                        $microlearningUser->company_id = $capsuleUser->company_id;
-                        $microlearningUser->user_id = $capsuleUser->user_id;
-                        $microlearningUser->added_on = $capsuleUser->added_on;
+                    'data'   => 'ERROR_USER_NOT_FOUND'
-                        $microlearningUser->updated_on = $capsuleUser->updated_on;
+                ]);
+            }
                         $microlearningUserMapper->insert($microlearningUser);
+            $topicUserMapper = MicrolearningTopicUserMapper::getInstance($this->adapter);
-                    }
+            $topicUser = $topicUserMapper->fetchOneByUserIdAndTopicId($user->id, $topic->id);
+            if(!$topicUser) {
+                return new JsonModel([
+                    'success'   => false,
+                    'data'   => 'ERROR_UNAUTHORIZED'
+                ]);
+            }
+            if($topicUser->access != MicrolearningTopicUser::ACCESS_REVOKE) {
+                return new JsonModel([
+                    'success'   => false,
-                }
+                    'data'   => 'ERROR_USER_ACCESS_CANNT_BE_UNLIMIT'
+                ]);
+            }
+            $topicUser->access = MicrolearningTopicUser::ACCESS_UNLIMITED;
+            $topicUser->updated_on = date('Y-m-d H:i:s');
+            try {
+                $topicUserMapper->update($topicUser);
+                $microlearningUserMapper = MicrolearningUserMapper::getInstance($this->adapter);
+                $microlearningUser = $microlearningUserMapper->fetchOneByUserIdAndCompanyId($topicUser->user_id, $topicUser->company_id);
+                if(!$microlearningUser) {
+                    $microlearningUser = new MicrolearningUser();
+                    $microlearningUser->company_id = $topicUser->company_id;
+                    $microlearningUser->user_id = $topicUser->user_id;
+                    $microlearningUser->added_on = $topicUser->added_on;
+                    $microlearningUser->updated_on = $topicUser->updated_on;
-                return new JsonModel([
+                    $microlearningUserMapper->insert($microlearningUser);
-                    'success' => true,
+                } else {
-                    'data' => 'LABEL_USER_ACCESS_HAS_BEEN_UNLIMITED'
+                    $microlearningUser->updated_on = $topicUser->updated_on;
-                ]);
+                    $microlearningUserMapper->update($microlearningUser);
+                }
+            } catch (\Exception $e) {
+                $this->logger->err('Error updating topic user: ' . $e->getMessage());
+                return new JsonModel([
+                    'success'   => false,
+                    'data'      => 'ERROR_UPDATING_TOPIC_USER'
+                ]);
+            }
+            return new JsonModel([
+                'success' => true,
+                'data' => 'LABEL_USER_ACCESS_HAS_BEEN_UNLIMITED'
-            } else {
+            ]);
-                return new JsonModel([
-                    'success'   => false,
-                    'data'      => $capsuleUserMapper->getError()
-                ]);
         } catch (\Exception $e) {
             $this->logger->err('Fatal error in unlimitAction: ' . $e->getMessage());
             return new JsonModel([
-        return new JsonModel([
+                'success' => false,
         $currentNetworkPlugin = $this->plugin('currentNetworkPlugin');
         $currentNetwork = $currentNetworkPlugin->getNetwork();
         $request    = $this->getRequest();
-        $topic_uuid     = $this->params()->fromRoute('topic_uuid');
-        $capsule_uuid   = $this->params()->fromRoute('capsule_uuid');
+        $topic_uuid     = $this->params()->fromRoute('topic_uuid');
                 'success'   => false,
                 'data'   => 'ERROR_TOPIC_NOT_FOUND'
             ]);
+        }
         if($topic->company_id != $currentCompany->id) {
             return new JsonModel([
                 'success'   => false,
                 'data'   => 'ERROR_UNAUTHORIZED'
             ]);
-        }
-        $capsuleMapper = MicrolearningCapsuleMapper::getInstance($this->adapter);
-        $capsule = $capsuleMapper->fetchOneByUuid($capsule_uuid);
-        if(!$capsule) {
-            return new JsonModel([
-                'success'   => false,
-                'data'   => 'ERROR_CAPSULE_NOT_FOUND'
-            ]);
-        }
-        if($capsule->topic_id != $topic->id) {
-            return new JsonModel([
-                'success'   => false,
-                'data'   => 'ERROR_UNAUTHORIZED'
-            ]);
-        }
+        }
         if($request->isPost()) {
-            $step = Functions::sanitizeFilterString($this->params()->fromPost('step'));
             if($step == 'validation') {
+            $step = Functions::sanitizeFilterString($this->params()->fromPost('step'));
+            if($step == 'validation') {
                 $userMapper = UserMapper::getInstance($this->adapter);
-                $capsuleUserMapper = MicrolearningCapsuleUserMapper::getInstance($this->adapter);
+                $topicUserMapper = MicrolearningTopicUserMapper::getInstance($this->adapter);
                         if(!in_array($email, $emails)) {
                             $user = $userMapper->fetchOneByEmail($email);
                             if($user) {
-                                $assigned_capsules =  $capsuleUserMapper->fetchCountByCompanyIdAndTopicIdAndUserId($topic->company_id, $topic->id, $user->id);
+                                $assigned_topics =  $topicUserMapper->fetchCountByCompanyIdAndTopicIdAndUserId($topic->company_id, $topic->id, $user->id);
                             } else {
-                                $assigned_capsules = 0;
+                                $assigned_topics = 0;
+                            }
                                 'id' => $count_users,
                                 'first_name' => $first_name,
                                 'last_name' => $last_name,
                                 'password'  => $password,
                                 'email' => $email,
-                                'assigned_capsules' => $assigned_capsules,
+                                'assigned_topics' => $assigned_topics,
                                 'company' => $company,
                                 'function' => $function,
                                 'group' => $group,
                                 'institution' => $institution,
                                 'program' => $program,
                                 'password'  => $password,
                                 'email' => $email,
                                 'status' => 'DUPLICATE IN EXCEL'
                             ]);
+                        }
+                    }
+                    // cache the users
-                    $key = md5($currentUser->id . '-' . $topic->uuid . '-' . $capsule->uuid);
+                    $key = md5($currentUser->id . '-' . $topic->uuid . '-' . $topic->uuid);
                     $this->cache->setItem($key, serialize($users));
                     // return the key
                     return new JsonModel([
                         'success' => true,
                         'data' => [
                             'key' => $key,
-                            'topic' => $topic->name,
-                            'capsule' => $capsule->name,
+                            'topic' => $topic->name,
                             'items' => [
                                 'ok' => $users,
                                 'error' => $errors,
                             ],
+                        ]
-                    ]);
                     ]);
                 } else {
                     $messages = [];
                     $form_messages = (array) $form->getMessages();
                     foreach($form_messages  as $fieldname => $field_messages)
                         'success'   => false,
                         'data'   => $messages
                     ]);
+                }
             } else if($step == 'process') {
+                // get the key from the post
                 $key = Functions::sanitizeFilterString($this->params()->fromPost('key'));
                 if(!$key) {
                     return new JsonModel([
                         'success' => false,
                         'data' => 'ERROR_CACHE_KEY_EMPTY'
                     ]);
+                }
+                // get the value from the cache
                 $value = $this->cache->getItem($key);
+                // if the value is not found, return an error
                 if(!$value) {
                     return new JsonModel([
                         'success' => false,
                         'data' => 'ERROR_CACHE_NOT_FOUND'
                     ]);
+                }
                 // unserialize the value
+                $records = unserialize($value);
-                $records = unserialize($value);
+                // if the value is not found, return an error
                 if(!$records) {
                     return new JsonModel([
                         'success' => false,
                         'data' => 'ERROR_CACHE_INVALID'
                     ]);
-                }
+                }
                 // get the network, company, company follower
                 $networkMapper = NetworkMapper::getInstance($this->adapter);
                 $companyMapper = CompanyMapper::getInstance($this->adapter);
                 $companyFollowerMapper = CompanyFollowerMapper::getInstance($this->adapter);
                 // get the connection, user, user password, topic user
                 $connectionMapper = ConnectionMapper::getInstance($this->adapter);
                 $userMapper = UserMapper::getInstance($this->adapter);
                 $userPasswordMapper = UserPasswordMapper::getInstance($this->adapter);
+                $topicUserMapper = MicrolearningTopicUserMapper::getInstance($this->adapter);
                 $capsuleUserMapper = MicrolearningCapsuleUserMapper::getInstance($this->adapter);
                 // get the microlearning extend user, microlearning extend user company, microlearning extend user function, microlearning extend user group, microlearning extend user institution, microlearning extend user program, microlearning extend user partner, microlearning extend user sector, microlearning extend user student type, microlearning extend user country
                 $microlearningExtendUserMapper = MicrolearningExtendUserMapper::getInstance($this->adapter);
                 $microlearningExtendUserCompanyMapper = MicrolearningExtendUserCompanyMapper::getInstance($this->adapter);
                 $microlearningExtendUserFunctionMapper = MicrolearningExtendUserFunctionMapper::getInstance($this->adapter);
                 $microlearningExtendUserPartnerMapper = MicrolearningExtendUserPartnerMapper::getInstance($this->adapter);
                 $microlearningExtendUserSectorMapper = MicrolearningExtendUserSectorMapper::getInstance($this->adapter);
                 $microlearningExtendUserStudentTypeMapper = MicrolearningExtendUserStudentTypeMapper::getInstance($this->adapter);
                 $microlearningExtendUserCountryMapper = MicrolearningExtendUserCountryMapper::getInstance($this->adapter);
                 // get the network default, user default for connection, company for follower
                 $networkDefault = $networkMapper->fetchOneByDefault();
                 $userDefaultForConnection = $userMapper->fetchOneDefaultForConnection();
                 $companyForFollower = $companyMapper->fetchOneDefaultForFollowers();
-                $companyForFollower = $companyMapper->fetchOneDefaultForFollowers();
                 // create the csv
                 $csv = "FIRST NAME|LAST NAME|EMAIL|STATUS\r\n";
                 // get the users processed, users assigned, user ids
                 $users_processed = 0;
                 $users_assigned = 0;
                 $user_ids = [];
                 foreach($records as $record)
+                {
-                    $first_name = $record['first_name'];
-                    $last_name = $record['last_name'];
-                    $password = $record['password'];
+                    $first_name = $record['first_name'];
-                    $email = $record['email'];
+                    $last_name = $record['last_name'];
                     $password = $record['password'];
                     $email = $record['email'];
                     $company = $record['company'];
                     $sector = $record['sector'];
                     $studentType = $record['studentType'];
                     $country = $record['country'];
                     $isAdult = strtolower(trim( $record['isAdult'])) == User::IS_ADULT_YES;
-                    $user = $userMapper->fetchOneByEmail($email);
-                    if(!$user) {
+                    $user = $userMapper->fetchOneByEmail($email);
+                    // if the user is not found, create the user
+                    if(!$user) {
                         // if the password is not empty, create the user
                         if($password) {
                             $password_hash = password_hash($password, PASSWORD_DEFAULT);
                     $last_name = $user->last_name;
                     $email = $user->email;
                     $users_processed++;
-                    $capsuleUser = $capsuleUserMapper->fetchOneByUserIdAndCapsuleId($user_id, $capsule->id);
+                    $topicUser = $topicUserMapper->fetchOneByUserIdAndTopicId($user_id, $topic->id);
-                    if($capsuleUser) {
+                    if($topicUser) {
                         $users_previous++;
                         $csv .= "$first_name|$last_name|$email|PREVIOUS FOUND \r\n";
                     } else {
-                        $capsuleUser = new MicrolearningCapsuleUser();
+                        $topicUser = new MicrolearningTopicUser();
-                        $capsuleUser->company_id = $capsule->company_id;
+                        $topicUser->company_id = $topic->company_id;
-                        $capsuleUser->topic_id = $capsule->topic_id;
+                        $topicUser->topic_id = $topic->id;
-                        $capsuleUser->capsule_id = $capsule->id;
+                        $topicUser->topic_id = $topic->id;
-                        $capsuleUser->user_id = $user_id;
+                        $topicUser->user_id = $user_id;
-                        $capsuleUser->access = MicrolearningCapsuleUser::ACCESS_UNLIMITED;
+                        $topicUser->access = MicrolearningTopicUser::ACCESS_UNLIMITED;
-                        if($capsuleUserMapper->insert($capsuleUser)) {
+                        if($topicUserMapper->insert($topicUser)) {
                             $notification = new Notification();
-                            $notification->company_id = $capsule->company_id;
+                            $notification->company_id = $topic->company_id;
                             $notification->user_id = $user_id;
-                            $notification->topic_id = $capsule->topic_id;
+                            $notification->topic_id = $topic->id;
-                            $notification->capsule_id = $capsule->id;
+                            $notification->topic_id = $topic->id;
                             $notification->type = Notification::TYPE_NEW_MICROLEARNING_CAPSULE;
-                            $notification->message  = 'LABEL_NOTIFICATION_NEW_MICROLEARNING_CAPSULE' . ' : ' . $capsule->name;
+                            $notification->message  = 'LABEL_NOTIFICATION_NEW_MICROLEARNING_CAPSULE' . ' : ' . $topic->name;
-                            $notification->url      = '/microlearning/capsules/' . $capsule->uuid .  '/detail';
+                            $notification->url      = '/microlearning/topics/' . $topic->uuid .  '/detail';
                             $notificationMapper->insert($notification);
                             $csv .= "$first_name|$last_name|$email|CAPSULE USER ASSIGNED\r\n";
                             $users_assigned++;
-                            $capsuleUser = $capsuleUserMapper->fetchOne($capsuleUser->id);
+                            $topicUser = $topicUserMapper->fetchOne($topicUser->id);
-                            if($capsuleUser) {
+                            if($topicUser) {
                                 $microlearningUserMapper = MicrolearningUserMapper::getInstance($this->adapter);
-                                $microlearningUser = $microlearningUserMapper->fetchOneByUserIdAndCompanyId($capsuleUser->user_id, $capsuleUser->company_id);
+                                $microlearningUser = $microlearningUserMapper->fetchOneByUserIdAndCompanyId($topicUser->user_id, $topicUser->company_id);
                                 if($microlearningUser) {
-                                    $microlearningUser->updated_on = $capsuleUser->updated_on;
+                                    $microlearningUser->updated_on = $topicUser->updated_on;
                                     $microlearningUserMapper->update($microlearningUser);
+                }
-                $users_in_the_capsule = $capsuleUserMapper->fetchCountByCompanyIdAndCapsuleId($capsule->company_id, $capsule->id);
+                $users_in_the_topic = $topicUserMapper->fetchCountByCompanyIdAndTopicId($topic->company_id, $topic->id);
                 return new JsonModel([
                     'success' => true,
                     'data' => [
                         'users_assigned' => $users_assigned,
                         'users_processed' => $users_processed,
-                        'users_in_the_capsule' => $users_in_the_capsule,
+                        'users_in_the_topic' => $users_in_the_topic,
             'success' => false,
             'data' => 'ERROR_METHOD_NOT_ALLOWED'
         ]);
+    }
+    /**
+     * Handles sending push notifications to selected users about a microlearning topic
+     *
+     * This action processes push notifications for microlearning topics:
+     * 1. Validates user permissions and input data
+     * 2. Processes the notification form
+     * 3. Sends push notifications to selected users' devices
+     *
+     * Required parameters:
+     * - topic_uuid: UUID of the microlearning topic
+     * - customer_uuids: Array of user UUIDs to receive the notification
+     * - push_template_id: UUID of the push notification template to use
+     *
+     * @return JsonModel Returns JSON response with:
+     *                   - success: true/false
+     *                   - data: Contains push_to_send count or error message
+     * @throws \Throwable When an error occurs during processing
      */
     public function notificationAction()
-    {
-        $request = $this->getRequest();
-        $currentUserPlugin = $this->plugin('currentUserPlugin');
-        $currentUser    = $currentUserPlugin->getUser();
-        $currentCompany = $currentUserPlugin->getCompany();
-        $request    = $this->getRequest();
-        $topic_uuid     = $this->params()->fromRoute('topic_uuid');
-        $capsule_uuid   = $this->params()->fromRoute('capsule_uuid');
-        $topicMapper = MicrolearningTopicMapper::getInstance($this->adapter);
-        $topic = $topicMapper->fetchOneByUuid($topic_uuid);
-        if(!$topic) {
-            return new JsonModel([
-                'success'   => false,
-                'data'   => 'ERROR_TOPIC_NOT_FOUND'
+    {
-            ]);
-        }
-        if($topic->company_id != $currentCompany->id) {
-            return new JsonModel([
-                'success'   => false,
-                'data'   => 'ERROR_UNAUTHORIZED'
-            ]);
-        }
-        $capsuleMapper = MicrolearningCapsuleMapper::getInstance($this->adapter);
-        $capsule = $capsuleMapper->fetchOneByUuid($capsule_uuid);
-        if(!$capsule) {
+        try {
-            return new JsonModel([
-                'success'   => false,
-                'data'   => 'ERROR_CAPSULE_NOT_FOUND'
-            ]);
-        }
-        if($capsule->topic_id != $topic->id) {
+            // Get current request and user context
-            return new JsonModel([
-                'success'   => false,
-                'data'   => 'ERROR_UNAUTHORIZED'
-            ]);
+            $request = $this->getRequest();
+            $currentUserPlugin = $this->plugin('currentUserPlugin');
+            $currentUser    = $currentUserPlugin->getUser();
+            $currentCompany = $currentUserPlugin->getCompany();
+            $topic_uuid     = $this->params()->fromRoute('topic_uuid');
+            // Validate topic UUID exists
+            if(!$topic_uuid) {
+                return new JsonModel([
+                    'success'   => false,
+                    'data'   => 'ERROR_TOPIC_UUID_NOT_FOUND'
+                ]);
+            }
+            // Validate company exists
+            if(!$currentCompany) {
+                return new JsonModel([
+                    'success'   => false,
+                    'data'   => 'ERROR_COMPANY_NOT_FOUND'
+                ]);
+            }
+            // Fetch and validate topic
+            $topicMapper = MicrolearningTopicMapper::getInstance($this->adapter);
+            $topic = $topicMapper->fetchOneByUuid($topic_uuid);
+            if(!$topic) {
+                return new JsonModel([
+                    'success'   => false,
+                    'data'   => 'ERROR_TOPIC_NOT_FOUND'
+                ]);
+            }
+            // Validate topic belongs to current company
+            if($topic->company_id != $currentCompany->id) {
+                return new JsonModel([
+                    'success'   => false,
+                    'data'   => 'ERROR_UNAUTHORIZED'
+                ]);
-        }
+            }
+            // Validate request method
+            if(!$request->isPost()) {
+                return new JsonModel([
+                    'success' => false,
+                    'data' => 'ERROR_METHOD_NOT_ALLOWED'
+                ]);
+            }
-        if($request->isPost()) {
+            // Process notification form
             $dataPost = $request->getPost()->toArray();
-            $form = new PushMicrolearningNotificationForm($this->adapter, $currentCompany->id);
+            $form = new PushMicrolearningNotificationForm($this->adapter, $currentCompany->id);
-            $form->setData($dataPost);
+            $form->setData($dataPost);
-            if($form->isValid()) {
-                $customer_uuids = $this->params()->fromPost('customer_uuids');
+            // Validate form data
-                if(!$customer_uuids) {
+            if(!$form->isValid()) {
-                    return new JsonModel([
+                $messages = [];
+                $form_messages = (array) $form->getMessages();
+                foreach($form_messages  as $fieldname => $field_messages)
+                {
+                    $messages[$fieldname] = array_values($field_messages);
+                }
+                return new JsonModel([
-                        'success' => false,
+                    'success'   => false,
+                    'data'      => $messages
-                        'data' => 'ERROR_NOT_SELECTED_CUSTOMERS'
+                ]);
-                    ]);
+            }
+            // Validate selected users
+            $customer_uuids = $this->params()->fromPost('customer_uuids');
+            if(!$customer_uuids) {
+                return new JsonModel([
+                    'success' => false,
+                    'data' => 'ERROR_NOT_SELECTED_CUSTOMERS'
+                ]);
+            }
-                }
+            // Get push template
-                $push_template_uuid = Functions::sanitizeFilterString($form->get('push_template_id')->getValue());
+            $push_template_uuid = Functions::sanitizeFilterString($form->get('push_template_id')->getValue());
-                $pushMapper = PushMapper::getInstance($this->adapter);
+            $pushMapper = PushMapper::getInstance($this->adapter);
-                $pushTemplateMapper = PushTemplateMapper::getInstance($this->adapter);
+            $pushTemplateMapper = PushTemplateMapper::getInstance($this->adapter);
+            $pushTemplate = $pushTemplateMapper->fetchOneByUuid($push_template_uuid);
+            if(!$pushTemplate) {
+                return new JsonModel([
+                    'success' => false,
+                    'data' => 'ERROR_PUSH_TEMPLATE_NOT_FOUND'
+                ]);
+            }
+            // Initialize push notification process
+            $applicationMapper = ApplicationMapper::getInstance($this->adapter);
+            $application = $applicationMapper->fetchOne(Application::TWOGETSKILLS);
+            $topicUserMapper = MicrolearningTopicUserMapper::getInstance($this->adapter);
+            $push_to_send = 0;
+            // Process each selected user
-                $pushTemplate = $pushTemplateMapper->fetchOneByUuid($push_template_uuid);
+            $userMapper = UserMapper::getInstance($this->adapter);
+            $deviceHistoryMapper = DeviceHistoryMapper::getInstance($this->adapter);
+            foreach($customer_uuids as $customer_uuid)
+            {
+                $user = $userMapper->fetchOneByUuid($customer_uuid);
+                if(!$user) {
+                    continue;
-                if(!$pushTemplate) {
-                    return new JsonModel([
-                        'success' => false,
-                        'data' => 'ERROR_PUSH_TEMPLATE_NOT_FOUND'
-                    ]);
-                }
-                $applicationMapper = ApplicationMapper::getInstance($this->adapter);
-                $application = $applicationMapper->fetchOne(Application::TWOGETSKILLS);
-                $capsuleUserMapper = MicrolearningCapsuleUserMapper::getInstance($this->adapter);
-                $push_to_send = 0;
-                $userMapper = UserMapper::getInstance($this->adapter);
-                $deviceHistoryMapper = DeviceHistoryMapper::getInstance($this->adapter);
-                foreach($customer_uuids as $customer_uuid)
+                }
-                {
-                    $user = $userMapper->fetchOneByUuid($customer_uuid);
-                    if(!$user) {
-                        continue;
-                    }
-                    $capsuleUser = $capsuleUserMapper->fetchOneByUserIdAndCapsuleId($user->id, $capsule->id);
+                $topicUser = $topicUserMapper->fetchOneByUserIdAndTopicId($user->id, $topic->id);
-                    if(!$capsuleUser) {
+                if(!$topicUser) {
+                    continue;
-                        continue;
+                }
-                    }
+                // Get user's latest device
+                $device = $deviceHistoryMapper->fetchLastDeviceByApplicationIdAndUserId(Application::TWOGETSKILLS, $user->id);
                     //$token = $deviceHistoryMapper->fetchLastDeviceTokenByApplicationIdAndUserId(Application::TWOGETSKILLS, $user->id);
-                    $device = $deviceHistoryMapper->fetchLastDeviceByApplicationIdAndUserId(Application::TWOGETSKILLS, $user->id);
+                if($device && $device->token) {
-                    if($device && $device->token) {
                         $key = $application->key;
-                        if($device->variant_id) {
                     $key = $application->key;
+                    if($device->variant_id) {
+                        $applicationVariantMapper = ApplicationVariantMapper::getInstance($this->adapter);
-                            $applicationVariantMapper = ApplicationVariantMapper::getInstance($this->adapter);
+                        $applicationVariant = $applicationVariantMapper->fetchOneByApplicationIdAndVariantId($device->application_id, $device->variant_id);
-                            $applicationVariant = $applicationVariantMapper->fetchOneByApplicationIdAndVariantId($device->application_id, $device->variant_id);
+                        if($applicationVariant) {
-                            if($applicationVariant) {
+                            $key = $applicationVariant->key;
-                                $key = $applicationVariant->key;
+                        } else {
-                            } else {
+                            $applicationVariant = $applicationVariantMapper->fetchOneByApplicationIdAndDefault($device->application_id);
+                            if($applicationVariant) {
+                                $key = $applicationVariant->key;
+                            }
+                        }
                                 $applicationVariant = $applicationVariantMapper->fetchOneByApplicationIdAndDefault($device->application_id);
-                                if($applicationVariant) {
-                                    $key = $applicationVariant->key;
-                                }
-                            }
+                    }
-                        }
+                    // Create push notification
-                        $push = new Push();
+                    $push = new Push();
-                        $push->status = Push::STATUS_PENDING;
+                    $push->status = Push::STATUS_PENDING;
-                        $push->data = json_encode([
+                    $push->data = json_encode([
-                            'server' => [
+                        'server' => [
-                                'key' => $key,
+                            'key' => $key,
-                            ],
+                        ],
-                            'push' => [
-                                'registration_ids'   => [
+                        'push' => [
-                                    $device->token,
-                                ],
-                                'notification' => [
-                                    'body' =>  $pushTemplate->body,
-                                    'title' => $pushTemplate->title,
+                            'registration_ids'   => [
-                                    'vibrate' => 1,
-                                    'sound' =>  1
-                                ],
-                                'data' => [
-                                    'command' => 'content-refresh',
-                                    'new_capsules' => '0',
-                                ]
-                            ]
-                        ]);
+                                $device->token,
+                            ],
+                            'notification' => [
+                                'body' =>  $pushTemplate->body,
+                                'title' => $pushTemplate->title,
+                                'vibrate' => 1,
                                 'sound' =>  1
-                        if($pushMapper->insert($push)) {
-                            $push_to_send = $push_to_send + 1;
-                        }
-                    }
-                }
-                if(0 == $push_to_send) {
-                    return new JsonModel([
-                        'success' => false,
-                        'data' => 'ERROR_NO_USER_DEVICES_WERE_FOUND_TO_SEND_PUSH'
-                    ]);
-                }
+                            ],
+                            'data' => [
-                return new JsonModel([
-                    'success' => true,
+                                'command' => 'content-refresh',
-                    'data' => [
-                        'push_to_send' => $push_to_send,
+                                'new_topics' => '0',
-                    ]
-                ]);
+                            ]
+                        ]
+                    ]);
-            } else {
+                    if($pushMapper->insert($push)) {
+                        $push_to_send = $push_to_send + 1;
+                    }
+                }
+            }
+            // Validate notifications were created
+            if(0 == $push_to_send) {
+                return new JsonModel([
+                    'success' => false,
+                    'data' => 'ERROR_NO_USER_DEVICES_WERE_FOUND_TO_SEND_PUSH'
+                ]);
+            }
-                $messages = [];
-                $form_messages = (array) $form->getMessages();
-                foreach($form_messages  as $fieldname => $field_messages)
-                {
-                    $messages[$fieldname] = array_values($field_messages);
-                }
+            return new JsonModel([
-                return new JsonModel([
-                    'success'   => false,
+                'success' => true,

Proyectos de Subversion LeadersLinked - Backend

(root)/module/LeadersLinked/src/Controller/MicrolearningAccessForStudentsController.php – Rev 17178 → 17248