Proyectos de Subversion LeadersLinked - Backend

Rev

Rev 16769 | Autoría | Comparar con el anterior | Ultima modificación | Ver Log | 

<?php
declare(strict_types=1);

namespace LeadersLinked\Controller;

use Laminas\Db\Adapter\AdapterInterface;

use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\Log\LoggerInterface;
use Laminas\View\Model\ViewModel;
use Laminas\View\Model\JsonModel;
use LeadersLinked\Library\Functions;
use LeadersLinked\Mapper\MicrolearningTopicMapper;
use LeadersLinked\Mapper\MicrolearningCapsuleMapper;
use LeadersLinked\Form\PushMicrolearningNotificationForm;
use LeadersLinked\Mapper\MicrolearningCapsuleUserMapper;
use LeadersLinked\Mapper\UserMapper;

use LeadersLinked\Model\User;

use LeadersLinked\Mapper\MicrolearningUserLogMapper;
use LeadersLinked\Mapper\MicrolearningSlideMapper;
use LeadersLinked\Form\ExtendUserMicrolearningForm;
use LeadersLinked\Form\ChangePasswordForm;
use LeadersLinked\Mapper\MicrolearningUserProgressMapper;
use LeadersLinked\Model\MicrolearningExtendUser;
use LeadersLinked\Mapper\MicrolearningExtendUserMapper;

use LeadersLinked\Mapper\MicrolearningExtendUserCompanyMapper;
use LeadersLinked\Mapper\MicrolearningExtendUserFunctionMapper;
use LeadersLinked\Mapper\MicrolearningExtendUserGroupMapper;
use LeadersLinked\Mapper\MicrolearningExtendUserInstitutionMapper;
use LeadersLinked\Mapper\MicrolearningExtendUserProgramMapper;
use LeadersLinked\Mapper\MicrolearningExtendUserPartnerMapper;
use LeadersLinked\Mapper\MicrolearningExtendUserSectorMapper;
use LeadersLinked\Mapper\MicrolearningExtendUserStudentTypeMapper;
use LeadersLinked\Mapper\CompanyUserMapper;
use LeadersLinked\Mapper\UserPasswordMapper;


class MicrolearningStudentsController extends AbstractActionController
{
    /**
     *
     * @var \Laminas\Db\Adapter\AdapterInterface
     */
    private $adapter;
    
    /**
     *
     * @var \LeadersLinked\Cache\CacheInterface
     */
    private $cache;
    
    
    /**
     *
     * @var \Laminas\Log\LoggerInterface
     */
    private $logger;
    
    /**
     *
     * @var array
     */
    private $config;
    
    
    /**
     *
     * @var \Laminas\Mvc\I18n\Translator
     */
    private $translator;
    
    
    /**
     *
     * @param \Laminas\Db\Adapter\AdapterInterface $adapter
     * @param \LeadersLinked\Cache\CacheInterface $cache
     * @param \Laminas\Log\LoggerInterface LoggerInterface $logger
     * @param array $config
     * @param \Laminas\Mvc\I18n\Translator $translator
     */
    public function __construct($adapter, $cache, $logger, $config, $translator)
    {
        $this->adapter      = $adapter;
        $this->cache        = $cache;
        $this->logger       = $logger;
        $this->config       = $config;
        $this->translator   = $translator;
    }
    
    public function indexAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();
        
        $request = $this->getRequest();
        
        if($request->isGet())
        {
            
            $headers  = $request->getHeaders();
            
            $isJson = false;
            if($headers->has('Accept')) {
                $accept = $headers->get('Accept');
                
                $prioritized = $accept->getPrioritized();
                
                foreach($prioritized as $key => $value) {
                    $raw = trim($value->getRaw());
                    
                    if(!$isJson) {
                        $isJson = strpos($raw, 'json');
                    }
                    
                }
            }
            
            if($isJson) {
               
                $search = $this->params()->fromQuery('search', []);
                $search = empty($search['value']) ? '' :  Functions::sanitizeFilterString($search['value']);
                
                $page               = intval($this->params()->fromQuery('start', 1), 10);
                $records_x_page     = intval($this->params()->fromQuery('length', 10), 10);
                $order =  $this->params()->fromQuery('order', []);
                $order_field        = empty($order[0]['column']) ? 99 :  intval($order[0]['column'], 10);
                $order_direction    = empty($order[0]['dir']) ? 'ASC' : strtoupper(Functions::sanitizeFilterString($order[0]['dir']));
                
                $fields =  ['first_name', 'last_name', 'email'];
                $order_field = isset($fields[$order_field]) ? $fields[$order_field] : 'first_name';
                
                if(!in_array($order_direction, ['ASC', 'DESC'])) {
                    $order_direction = 'ASC';
                }
                
                //$microlearningCapsuleMapper = MicrolearningCapsuleMapper::getInstance($this->adapter);
                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                $microlearningCapsulUserMapper = MicrolearningCapsuleUserMapper::getInstance($this->adapter);
                $microlearningUserProgressMapper = MicrolearningUserProgressMapper::getInstance($this->adapter);
                
                $userMapper = UserMapper::getInstance($this->adapter);
                $paginator = $userMapper->fetchAllDataTableStudensByCompanyId($currentCompany->id, $search, $page, $records_x_page, $order_field, $order_direction);
                
                $acl = $this->getEvent()->getViewModel()->getVariable('acl');
                $allowEdit = $acl->isAllowed($currentUser->usertype_id, 'microlearning/students/edit');
                $allowTimeline = $acl->isAllowed($currentUser->usertype_id, 'microlearning/students/timeline');
                $allowUnblock = $acl->isAllowed($currentUser->usertype_id, 'microlearning/students/unblock');
                $allowChangePassword = $acl->isAllowed($currentUser->usertype_id, 'microlearning/students/change-password');
                
                
                
                $items = [ ];
                $records = $paginator->getCurrentItems();
                
  

                foreach($records as $record)
                {

                    
                    $userCapsules = $microlearningCapsulUserMapper->fetchAllActiveByUserId($record['id']);

                    $total_asigned = count($userCapsules);
                    $total_without_starting = 0; 
                    $total_started = 0; 
                    $total_completed = 0;
                    
                    foreach($userCapsules as $userCapsule)
                    {
                        $userProgress = $microlearningUserProgressMapper->fetchOneByUseridAndCapsuleId($userCapsule->user_id, $userCapsule->capsule_id);
                        if($userProgress) {
                            
                            if($userProgress->completed) {
                                $total_completed++;
                            }  else {
                                $total_started++;
                            } 
                            
                        } else {
                            $total_without_starting++;
                        }
                    
                    }
                    
                    
                    $actions = [];
                    if($allowEdit) {
                        $actions['link_edit'] = $this->url()->fromRoute('microlearning/students/edit', ['id' => $record['uuid'] ]  );
                    } 
                    if($allowTimeline) {
                        $actions['link_timeline'] = $this->url()->fromRoute('microlearning/students/timeline', ['id' => $record['uuid'] ]  );
                    } 
                    
                    $totalOtherCompanies = $companyUserMapper->fetchCountOtherCompaniesByCompanyIdAndUserId($currentCompany->id, $record['id']);
                    if(!$totalOtherCompanies) {
                        
                        $actions['link_change_password'] = $allowChangePassword ? $this->url()->fromRoute('microlearning/students/change-password', ['id' => $record['uuid'] ]) : '';
                        if($record['blocked'] == User::BLOCKED_YES ) {
                            $actions['link_unblock'] = $allowUnblock ? $this->url()->fromRoute('microlearning/students/unblock', ['id' => $record['uuid'] ]) : '';
                        }
                    }
                    
                    $details = [
                        'total_asigned' => $total_asigned,
                        'total_without_starting' => $total_without_starting,
                        'total_started' => $total_started,
                        'total_completed' => $total_completed,
                    ]; 


                    $item = [
                        'uuid' => $record['uuid'],
                        'first_name' => $record['first_name'],
                        'last_name' => $record['last_name'],
                        'email' => $record['email'],
                        'details' => $details,
                        'actions' => $actions
                    ];
                    
                    
                    array_push($items, $item);
                    
                    
                }
                
                $data['items'] = $items;
                $data['total'] = $paginator->getTotalItemCount();
                
                
                return new JsonModel([
                    'success' => true,
                    'data' => $data
                ]);
            } else {
                $formPushNotification = new PushMicrolearningNotificationForm($this->adapter, $currentCompany->id);
                
                $formExtendUser = new ExtendUserMicrolearningForm($this->adapter, $currentCompany->id);
                $formChangePassword = new ChangePasswordForm();
                
                $this->layout()->setTemplate('layout/layout-backend');
                $viewModel = new ViewModel();
                $viewModel->setTemplate('leaders-linked/microlearning-students/index.phtml');
                $viewModel->setVariables([
                    'formPushNotification' => $formPushNotification,
                    'formExtendUser' => $formExtendUser,
                    'formChangePassword' => $formChangePassword,
                ]);
                
                return $viewModel ;
            }
            
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);;
        }
    }
    
    
    
    public function editAction()
    {
        
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser    = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();
        
        $request    = $this->getRequest();
        $user_uuid  = $this->params()->fromRoute('id');

        
        $userMapper = UserMapper::getInstance($this->adapter);
        $user = $userMapper->fetchOneByUuid($user_uuid);
        
        if(!$user) {
            return new JsonModel([
                'success'   => false,
                'data'   => 'ERROR_USER_NOT_FOUND'
            ]);
        }
        
        $microlearningCapsuleUserMapper = MicrolearningCapsuleUserMapper::getInstance($this->adapter);
        $total = $microlearningCapsuleUserMapper->fetchCountByCompanyIdAndUserId($currentCompany->id, $user->id);
        
        if(!$total) {
            return new JsonModel([
                'success'   => false,
                'data'   => 'ERROR_UNAUTHORIZED'
            ]);
        } 
        
        
        if($request->isGet()) {
            

            $data = [
                'first_name' => $user->first_name,
                'last_name' => $user->last_name,
                'email' => $user->email,
                'company_id' => '',
                'function_id' => '',
                'group_id' => '',
                'institution_id' => '',
                'partner_id' => '',
                'program_id' => '',
                'sector_id' => '',
                'student_type_id' => '',
                
            ];
            
            $microlearningExtendUserMapper = MicrolearningExtendUserMapper::getInstance($this->adapter);
            $microlearningExtendUser = $microlearningExtendUserMapper->fetchOneByCompanyIdAndUserId($currentCompany->id, $user->id);
           
            if($microlearningExtendUser) {
                if($microlearningExtendUser->extend_company_id) {
                    $microlearningExtendUserCompanyMapper = MicrolearningExtendUserCompanyMapper::getInstance($this->adapter);
                    $microlearningExtendUserCompany = $microlearningExtendUserCompanyMapper->fetchOne($microlearningExtendUser->extend_company_id);
                    if($microlearningExtendUserCompany) {
                        $data['company_id'] = $microlearningExtendUserCompany->uuid;
                    }
                }
                
            }
            
            if($microlearningExtendUser) {
                if($microlearningExtendUser->extend_function_id) {
                    $microlearningExtendUserFunctionMapper = MicrolearningExtendUserFunctionMapper::getInstance($this->adapter);
                    $microlearningExtendUserFunction = $microlearningExtendUserFunctionMapper->fetchOne($microlearningExtendUser->extend_function_id);
                    if($microlearningExtendUserFunction) {
                        $data['function_id'] = $microlearningExtendUserFunction->uuid;
                    }
                }
            }
            
            if($microlearningExtendUser) {
                if($microlearningExtendUser->extend_group_id) {
                    $microlearningExtendUserGroupMapper = MicrolearningExtendUserGroupMapper::getInstance($this->adapter);
                    $microlearningExtendUserGroup = $microlearningExtendUserGroupMapper->fetchOne($microlearningExtendUser->extend_group_id);
                    if($microlearningExtendUserGroup) {
                        $data['group_id'] = $microlearningExtendUserGroup->uuid;
                    }
                }
            }
            
            if($microlearningExtendUser) {
                if($microlearningExtendUser->extend_institution_id) {
                    $microlearningExtendUserInstitutionMapper = MicrolearningExtendUserInstitutionMapper::getInstance($this->adapter);
                    $microlearningExtendUserInstitution = $microlearningExtendUserInstitutionMapper->fetchOne($microlearningExtendUser->extend_institution_id);
                    if($microlearningExtendUserInstitution) {
                        $data['institution_id'] = $microlearningExtendUserInstitution->uuid;
                    }
                }
            }
            
            if($microlearningExtendUser) {
                if($microlearningExtendUser->extend_partner_id) {
                    $microlearningExtendUserPartnerMapper = MicrolearningExtendUserPartnerMapper::getInstance($this->adapter);
                    $microlearningExtendUserPartner = $microlearningExtendUserPartnerMapper->fetchOne($microlearningExtendUser->extend_partner_id);
                    if($microlearningExtendUserPartner) {
                        $data['partner_id'] = $microlearningExtendUserPartner->uuid;
                    }
                }
            }
            
            if($microlearningExtendUser) {
                if($microlearningExtendUser->extend_program_id) {
                    $microlearningExtendUserProgramMapper = MicrolearningExtendUserProgramMapper::getInstance($this->adapter);
                    $microlearningExtendUserProgram = $microlearningExtendUserProgramMapper->fetchOne($microlearningExtendUser->extend_program_id);
                    if($microlearningExtendUserProgram) {
                        $data['program_id'] = $microlearningExtendUserProgram->uuid;
                    }
                }
            }
            
            if($microlearningExtendUser) {
                if($microlearningExtendUser->extend_sector_id) {
                    $microlearningExtendUserSectorMapper = MicrolearningExtendUserSectorMapper::getInstance($this->adapter);
                    $microlearningExtendUserSector = $microlearningExtendUserSectorMapper->fetchOne($microlearningExtendUser->extend_sector_id);
                    if($microlearningExtendUserSector) {
                        $data['sector_id'] = $microlearningExtendUserSector->uuid;
                    }
                }
            }
            
            if($microlearningExtendUser) {
                if($microlearningExtendUser->extend_student_type_id) {
                    $microlearningExtendUserStudentTypeMapper = MicrolearningExtendUserStudentTypeMapper::getInstance($this->adapter);
                    $microlearningExtendUserStudentType = $microlearningExtendUserStudentTypeMapper->fetchOne($microlearningExtendUser->extend_student_type_id);
                    if($microlearningExtendUserStudentType) {
                        $data['student_type_id'] = $microlearningExtendUserStudentType->uuid;
                    }
                }
            }
            
            
            return new JsonModel([
                'success'   => true,
                'data'   => $data,
            ]);
            
        }
        
        
        if($request->isPost()) {
            $form = new  ExtendUserMicrolearningForm($this->adapter, $currentCompany->id);
            $dataPost = $request->getPost()->toArray();
            
            $form->setData($dataPost);
            
            if($form->isValid()) {
                $dataPost = (array) $form->getData();
                
                $microlearningExtendUserMapper = MicrolearningExtendUserMapper::getInstance($this->adapter);
                $microlearningExtendUser = $microlearningExtendUserMapper->fetchOneByCompanyIdAndUserId($currentCompany->id, $user->id);
                if(!$microlearningExtendUser) {
                    $microlearningExtendUser = new MicrolearningExtendUser();
                    $microlearningExtendUser->company_id = $currentCompany->id; 
                    $microlearningExtendUser->user_id = $user->id;
                } 
                
                
                $extend_company_uuid        = Functions::sanitizeFilterString($this->params()->fromPost('company_id'));
                $extend_function_uuid       = Functions::sanitizeFilterString($this->params()->fromPost('function_id'));
                $extend_group_uuid          = Functions::sanitizeFilterString($this->params()->fromPost('group_id'));
                $extend_institution_uuid    = Functions::sanitizeFilterString($this->params()->fromPost('institution_id'));
                $extend_program_uuid        = Functions::sanitizeFilterString($this->params()->fromPost('program_id'));
                $extend_partner_uuid        = Functions::sanitizeFilterString($this->params()->fromPost('partner_id'));
                $extend_sector_uuid         = Functions::sanitizeFilterString($this->params()->fromPost('sector_id'));
                $extend_student_type_uuid   = Functions::sanitizeFilterString($this->params()->fromPost('student_type_id'));
                
            
                if($extend_company_uuid) {
                    $microlearningExtendUserCompanyMapper = MicrolearningExtendUserCompanyMapper::getInstance($this->adapter);
                    $microlearningExtendUserCompany = $microlearningExtendUserCompanyMapper->fetchOneByUuid($extend_company_uuid);
                    if($microlearningExtendUserCompany && $microlearningExtendUserCompany->company_id = $currentCompany->id) {
                        $microlearningExtendUser->extend_company_id = $microlearningExtendUserCompany->id;
                    } else {
                        $microlearningExtendUser->extend_company_id = null;
                    } 
                    
                } else {
                    $microlearningExtendUser->extend_company_id = null;
                } 
                
                
                if($extend_function_uuid) {
                    $microlearningExtendUserFunctionMapper = MicrolearningExtendUserFunctionMapper::getInstance($this->adapter);
                    $microlearningExtendUserFunction = $microlearningExtendUserFunctionMapper->fetchOneByUuid($extend_function_uuid);
                    if($microlearningExtendUserFunction && $microlearningExtendUserFunction->company_id = $currentCompany->id) {
                        $microlearningExtendUser->extend_function_id = $microlearningExtendUserFunction->id;
                    } else {
                        $microlearningExtendUser->extend_function_id = null;
                    }
                    
                } else {
                    $microlearningExtendUser->extend_function_id = null;
                } 
                
                if($extend_group_uuid) {
                    $microlearningExtendUserGroupMapper = MicrolearningExtendUserGroupMapper::getInstance($this->adapter);
                    $microlearningExtendUserGroup = $microlearningExtendUserGroupMapper->fetchOneByUuid($extend_group_uuid);
                    if($microlearningExtendUserGroup && $microlearningExtendUserGroup->company_id = $currentCompany->id) {
                        $microlearningExtendUser->extend_group_id = $microlearningExtendUserGroup->id;
                    } else {
                        $microlearningExtendUser->extend_group_id = null;
                    }
                    
                } else {
                    $microlearningExtendUser->extend_group_id = null;
                } 
                
                if($extend_institution_uuid) {
                    $microlearningExtendUserInstitutionMapper = MicrolearningExtendUserInstitutionMapper::getInstance($this->adapter);
                    $microlearningExtendUserInstitution = $microlearningExtendUserInstitutionMapper->fetchOneByUuid($extend_institution_uuid);
                    if($microlearningExtendUserInstitution && $microlearningExtendUserInstitution->company_id = $currentCompany->id) {
                        $microlearningExtendUser->extend_institution_id = $microlearningExtendUserInstitution->id;
                    } else {
                        $microlearningExtendUser->extend_institution_id = null;
                    }
                    
                } else {
                    $microlearningExtendUser->extend_institution_id = null;
                } 
                
                if($extend_program_uuid) {
                    $microlearningExtendUserProgramMapper = MicrolearningExtendUserProgramMapper::getInstance($this->adapter);
                    $microlearningExtendUserProgram = $microlearningExtendUserProgramMapper->fetchOneByUuid($extend_program_uuid);
                    if($microlearningExtendUserProgram && $microlearningExtendUserProgram->company_id = $currentCompany->id) {
                        $microlearningExtendUser->extend_program_id = $microlearningExtendUserProgram->id;
                    } else {
                        $microlearningExtendUser->extend_program_id = null;
                    }
                    
                } else {
                    $microlearningExtendUser->extend_program_id = null;
                } 
                
                if($extend_partner_uuid) {
                    $microlearningExtendUserPartnerMapper = MicrolearningExtendUserPartnerMapper::getInstance($this->adapter);
                    $microlearningExtendUserPartner = $microlearningExtendUserPartnerMapper->fetchOneByUuid($extend_partner_uuid);
                    if($microlearningExtendUserPartner && $microlearningExtendUserPartner->company_id = $currentCompany->id) {
                        $microlearningExtendUser->extend_partner_id = $microlearningExtendUserPartner->id;
                    } else {
                        $microlearningExtendUser->extend_partner_id = null;
                    }
                    
                } else {
                    $microlearningExtendUser->extend_partner_id = null;
                } 
                
                if($extend_sector_uuid) {
                    $microlearningExtendUserSectorMapper = MicrolearningExtendUserSectorMapper::getInstance($this->adapter);
                    $microlearningExtendUserSector = $microlearningExtendUserSectorMapper->fetchOneByUuid($extend_sector_uuid);
                    if($microlearningExtendUserSector && $microlearningExtendUserSector->company_id = $currentCompany->id) {
                        $microlearningExtendUser->extend_sector_id = $microlearningExtendUserSector->id;
                    } else {
                        $microlearningExtendUser->extend_sector_id = null;
                    }
                    
                } else {
                    $microlearningExtendUser->extend_sector_id = null;
                } 
                
                if($extend_student_type_uuid) {
                    $microlearningExtendUserStudentTypeMapper = MicrolearningExtendUserStudentTypeMapper::getInstance($this->adapter);
                    $microlearningExtendUserStudentType = $microlearningExtendUserStudentTypeMapper->fetchOneByUuid($extend_student_type_uuid);
                    if($microlearningExtendUserStudentType && $microlearningExtendUserStudentType->company_id = $currentCompany->id) {
                        $microlearningExtendUser->extend_student_type_id = $microlearningExtendUserStudentType->id;
                    } else {
                        $microlearningExtendUser->extend_student_type_id = null;
                    }
                    
                } else {
                    $microlearningExtendUser->extend_student_type_id = null;
                } 
                
 
                
                if($microlearningExtendUser->id) {
                    $result = $microlearningExtendUserMapper->update($microlearningExtendUser);
                    if($result) {
                        $this->logger->info('Se actualizo la información extendida de micro aprendizaje  del usuario ' . $user->email, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                        
                        $data = [
                            'success'   => true,
                            'data'   => 'LABEL_RECORD_ADDED'
                        ];
                    } else {
                        $data = [
                            'success'   => false,
                            'data'      => $microlearningExtendUserMapper->getError()
                        ];
                        
                    }
                } else {
                    $result = $microlearningExtendUserMapper->insert($microlearningExtendUser);
                    if($result) {
                        $this->logger->info('Se agrego la información extendida de micro aprendizaje  del usuario ' . $user->email, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                        
                        $data = [
                            'success'   => true,
                            'data'   => 'LABEL_RECORD_ADDED'
                        ];
                    } else {
                        $data = [
                            'success'   => false,
                            'data'      => $microlearningExtendUserMapper->getError()
                        ];
                        
                    }
                } 
               
                
         
                
                return new JsonModel($data);
                
            } else {
                $messages = [];
                $form_messages = (array) $form->getMessages();
                foreach($form_messages  as $fieldname => $field_messages)
                {
                    
                    $messages[$fieldname] = array_values($field_messages);
                }
                
                return new JsonModel([
                    'success'   => false,
                    'data'   => $messages
                ]);
            }
            
        } else {
            $data = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
            
            return new JsonModel($data);
        }
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    
    public function timelineAction()
    {
        
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser    = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();
        
        $request    = $this->getRequest();
        $user_uuid  = $this->params()->fromRoute('id');
        
        
        $userMapper = UserMapper::getInstance($this->adapter);
        $user = $userMapper->fetchOneByUuid($user_uuid);
        
        if(!$user) {
            return new JsonModel([
                'success'   => false,
                'data'   => 'ERROR_USER_NOT_FOUND'
            ]);
        }
        
        if($request->isGet()) {
            $page = intval(filter_var($this->params()->fromQuery('page'), FILTER_SANITIZE_NUMBER_INT) , 10);
            if(!$page) {
                $page = 1;
            } 
            $records_x_page = 10;
            
            $microlearningTopicMapper = MicrolearningTopicMapper::getInstance($this->adapter);
            $microlearningCapsuleMapper = MicrolearningCapsuleMapper::getInstance($this->adapter);
            $microlearningSlideMapper = MicrolearningSlideMapper::getInstance($this->adapter);
            
            $topics = [];
            $capsules = []; 
            $slides = [] ; 
            
            
            $microlearningUserLogMapper = MicrolearningUserLogMapper::getInstance($this->adapter); 
        
            $paginator = $microlearningUserLogMapper->getAllMessagesPaginatorByUserIdAndCompanyId($user->id, $currentCompany->id, $page, $records_x_page); 
            
            $items = [] ; 
            foreach($paginator->getCurrentItems() as $record)
            {
                $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->added_on); 
                
                $item = [
                    'activity' => $record->activity,
                    'added_on' => $dt->format('d/m/Y h:i a')
                ]; 
                
                if($record->topic_id) {
                    
                    if(isset($topics[$record->topic_id])) {
                        $topic = $topics[ $record->topic_id ]; 
                    }  else {
                        $topic = $microlearningTopicMapper->fetchOne( $record->topic_id ); 
                    } 
                    
                    if($topic) {
                        $item['topic'] = $topic->name;
                    } 
                    
                    if(isset($capsules[$record->capsule_id])) {
                        $capsule = $capsules[ $record->capsule_id ];
                    }  else {
                        $capsule = $microlearningCapsuleMapper->fetchOne( $record->capsule_id );
                    }
                    
                    if($capsule) {
                        $item['capsule'] = $capsule->name;
                    } 
                    
                    if(isset($slides[$record->slide_id])) {
                        $slide = $slides[ $record->slide_id ];
                    }  else {
                        $slide = $microlearningSlideMapper->fetchOne( $record->slide_id );
                    }
                    
                    if($slide) {
                        $item['slide'] = $slide->name;
                    } 
                } 
                
                
                array_push($items, $item); 
            }
            
            $response = [
                'success' => true,
                'data' => [
                    'total' => [
                        'count' => $paginator->getTotalItemCount(),
                        'pages' => $paginator->getPages()->pageCount,
                    ],
                    'current' => [
                        'items'    => $items,
                        'page'     => $paginator->getCurrentPageNumber(),
                        'count'    => $paginator->getCurrentItemCount(),
                    ]
                ]
            ];
            
            return new JsonModel($response);
        
        }
        
        

        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    
    
    public function unblockAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $request = $this->getRequest();
        
        
        if($request->isPost()) {
            
            $uuid = $this->params()->fromRoute('id');
            if(!$uuid) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_INVALID_PARAMETER'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($uuid);
            
            if(!$user) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
            if($user->blocked == User::BLOCKED_NO) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_IS_NOT_BLOCKED'
                ]);
            }
            
            
            
            $result = $userMapper->unblock($user);
            if($result) {
                $this->logger->info('El usuario : ' . $user->email . ' ha sido desbloqueado ', ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                
                return new JsonModel([
                    'success'   => true,
                    'data'      => 'LABEL_USER_HAS_BEEN_UNBLOCKED',
                ]);
            }  else {
                
                return new JsonModel([
                    'success'   => false,
                    'data'      => $userMapper->getError()
                ]);
            }
            
            
        }
        
        
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    
    public function changePasswordAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $request = $this->getRequest();
        
        if($request->isGet()) {
            $uuid = $this->params()->fromRoute('id');
            if(!$uuid) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_INVALID_PARAMETER'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($uuid);
            
            
            
            if($user) {
                return new JsonModel([
                    'success'   => true,
                    'data'      => [
                        'first_name' => $user->first_name,
                        'last_name' => $user->last_name,
                        'email' => $user->email,
                    ]
                ]);
            } else {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
        }
        
        if($request->isPost()) {
            
            $uuid = $this->params()->fromRoute('id');
            if(!$uuid) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_INVALID_PARAMETER'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($uuid);
            
            if(!$user) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
            
            $dataPost = $request->getPost()->toArray();
            $form = new ChangePasswordForm();
            $form->setData($dataPost);
            
            if($form->isValid()) {
                
                
                
                $data = (array) $form->getData();
                $password = $data['password'];
                
                
                
                $userPasswordMapper = UserPasswordMapper::getInstance($this->adapter);
                $userPasswords = $userPasswordMapper->fetchAllByUserId($user->id);
                
                $oldPassword = false;
                foreach($userPasswords as $userPassword)
                {
                    if(password_verify($password, $userPassword->password) || (md5($password) == $userPassword->password))
                    {
                        $oldPassword = true;
                        break;
                    }
                }
                
                if($oldPassword) {
                    $this->logger->err('Cambio de contraseña del usuario - error contraseña ya utilizada anteriormente', ['user_id' =>  $currentUser->id, 'ip' => Functions::getUserIP()]);
                    
                    return new JsonModel([
                        'success'   => false,
                        'data'      => 'ERROR_PASSWORD_HAS_ALREADY_BEEN_USED'
                        
                    ]);
                } else {
                    $password_hash = password_hash($password, PASSWORD_DEFAULT);
                    
                    
                    $result = $userMapper->updatePassword($user, $password_hash);
                    if($result) {
                        $this->logger->info('Cambio de contraseña del usuario realizado', ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                        
                        
                        return new JsonModel([
                            'success'   => true,
                            'data'      => 'LABEL_YOUR_PASSWORD_HAS_BEEN_UPDATED'
                            
                        ]);
                    } else {
                        $this->logger->err('Cambio de contraseña del usuario - error desconocido', ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                        
                        return new JsonModel([
                            'success'   => true,
                            'data'      => 'ERROR_THERE_WAS_AN_ERROR'
                            
                        ]);
                    }
                }
                
            } else {
                $messages = [];
                
                $form_messages = (array) $form->getMessages();
                foreach($form_messages  as $fieldname => $field_messages)
                {
                    $messages[$fieldname] = array_values($field_messages);
                }
                
                return new JsonModel([
                    'success'   => false,
                    'data'   => $messages
                ]);
            }
            
        }
        
        
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    
   
    
}