Proyectos de Subversion LeadersLinked - Backend

Rev

Rev 17001 | 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\Mapper\MicrolearningTopicMapper;
use LeadersLinked\Mapper\MicrolearningCapsuleMapper;
use LeadersLinked\Form\TopicCapsuleForm;
use LeadersLinked\Form\PushMicrolearningNotificationForm;
use LeadersLinked\Mapper\QueryMapper;
use LeadersLinked\Mapper\MicrolearningCapsuleUserMapper;
use LeadersLinked\Mapper\UserMapper;
use Laminas\Hydrator\ArraySerializableHydrator;
use Laminas\Db\ResultSet\HydratingResultSet;
use Laminas\Paginator\Adapter\DbSelect;
use Laminas\Paginator\Paginator;
use LeadersLinked\Model\MicrolearningCapsuleUser;
use LeadersLinked\Mapper\ApplicationMapper;
use LeadersLinked\Mapper\PushMapper;
use LeadersLinked\Mapper\PushTemplateMapper;
use LeadersLinked\Mapper\DeviceHistoryMapper;
use LeadersLinked\Model\Push;
use LeadersLinked\Model\Application;
use LeadersLinked\Form\CapsuleCustomerUploadForm;
use PhpOffice\PhpSpreadsheet\IOFactory;
use LeadersLinked\Model\User;
use LeadersLinked\Model\UserType;
use LeadersLinked\Model\UserPassword;
use LeadersLinked\Mapper\MicrolearningUserMapper;
use LeadersLinked\Mapper\UserPasswordMapper;
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\Model\MicrolearningExtendUser;
use LeadersLinked\Model\MicrolearningExtendUserCompany;
use LeadersLinked\Model\MicrolearningExtendUserFunction;
use LeadersLinked\Model\MicrolearningExtendUserGroup;
use LeadersLinked\Model\MicrolearningExtendUserInstitution;
use LeadersLinked\Model\MicrolearningExtendUserProgram;
use LeadersLinked\Model\MicrolearningExtendUserPartner;
use LeadersLinked\Model\MicrolearningExtendUserSector;
use LeadersLinked\Model\MicrolearningExtendUserStudentType;
use LeadersLinked\Model\MicrolearningUser;
use LeadersLinked\Model\Notification;
use LeadersLinked\Mapper\ApplicationVariantMapper;
use LeadersLinked\Mapper\MicrolearningExtendUserCountryMapper;
use LeadersLinked\Model\MicrolearningExtendUserCountry;
use LeadersLinked\Model\Network;
use LeadersLinked\Mapper\CompanyMapper;
use LeadersLinked\Mapper\NetworkMapper;
use LeadersLinked\Mapper\CompanyFollowerMapper;
use LeadersLinked\Mapper\ConnectionMapper;
use LeadersLinked\Model\Connection;
use LeadersLinked\Model\CompanyFollower;
use LeadersLinked\Library\Functions;
use LeadersLinked\Cache\CacheInterface;
use LeadersLinked\Cache\CacheImpl;
use LeadersLinked\Mapper\NotificationMapper;


class MicrolearningAccessForStudentsController 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) {
                $topic_uuid     = Functions::sanitizeFilterString($this->params()->fromQuery('topic_uuid'));
                $capsule_uuid   = Functions::sanitizeFilterString($this->params()->fromQuery('capsule_uuid'));
                
                $data = [
                    'link_upload' => '',
                    'items' => [] ,
                    'total' => 0,
                    
                ];
                
                
                if(!$topic_uuid) {
                    return new JsonModel([
                        'success' => true,
                        'data' => $data
                    ]);
                    
                }
                
                
                $topicMapper = MicrolearningTopicMapper::getInstance($this->adapter);
                $topic = $topicMapper->fetchOneByUuid($topic_uuid);
                if(!$topic) {
                    return new JsonModel([
                        'success' => true,
                        'data' => 'ERROR_TOPIC_NOT_FOUND'
                    ]);
                }
                
                if($topic->company_id != $currentCompany->id) {
                    return new JsonModel([
                        'success' => true,
                        'data' => 'ERROR_UNAUTHORIZED'
                    ]);
                }
                
                
                
                if(!$capsule_uuid) {
                    $capsuleMapper = MicrolearningCapsuleMapper::getInstance($this->adapter);
                    $records = $capsuleMapper->fetchAllByCompanyIdAndTopicId($topic->company_id, $topic->id);
                    
                    $capsules = [];
                    foreach($records as $record)
                    {
                        if(!$capsule_uuid) {
                            $capsule_uuid = $record->uuid;
                        }
                        
                        $capsules[ $record->uuid ] = $record->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'
                    ]);
                }
                
                if($capsule->topic_id != $topic->id) {
                    return new JsonModel([
                        'success' => true,
                        'data' => 'ERROR_UNAUTHORIZED'
                    ]);
                }
                

                $data['link_upload'] = $this->url()->fromRoute('microlearning/access-for-students/upload',['topic_uuid' => $topic->uuid, 'capsule_uuid' => $capsule->uuid]);
                $data['link_notification'] = $this->url()->fromRoute('microlearning/access-for-students/notification',['topic_uuid' => $topic->uuid, 'capsule_uuid' => $capsule->uuid]);
                
                $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 =  ['uuid', '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';
                }
                
                $acl = $this->getEvent()->getViewModel()->getVariable('acl');
                $allowRevoke = $acl->isAllowed($currentUser->usertype_id, 'microlearning/access-for-students/revoke');
                $allowUnlimit = $acl->isAllowed($currentUser->usertype_id, 'microlearning/access-for-students/unlimit');
                $allowCancel = $acl->isAllowed($currentUser->usertype_id, 'microlearning/access-for-students/cancel');
                $allowReactive = $acl->isAllowed($currentUser->usertype_id, 'microlearning/access-for-students/reactive');
                
                $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->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.topic_id', $capsule->topic_id);
                $select->where->equalTo('tb1.capsule_id', $capsule->id);
                
                if($search) {
                    $select->where->nest()
                    ->like('first_name', '%' . $search . '%')
                    ->or->like('last_name', '%' . $search . '%')
                    ->or->like('email', '%' . $search . '%')
                    ->unnest();
                    
                }
                
                
                $select->order($order_field . ' ' . $order_direction);
                
                $hydrator   = new ArraySerializableHydrator();
                $resultset  = new HydratingResultSet($hydrator);
                
                $adapter = new DbSelect($select, $sql, $resultset);
                $paginator = new Paginator($adapter);
                $paginator->setItemCountPerPage($records_x_page);
                $paginator->setCurrentPageNumber($page);
                
                
                $items = [ ];
                $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 :
                            $actions['link_revoke'] = $allowRevoke ? $this->url()->fromRoute('microlearning/access-for-students/revoke', $params) : '';
                            $details['access'] = 'LABEL_UNLIMIT';
                            break;
                            
                        case MicrolearningCapsuleUser::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 :
                            $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 :
                            $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_SUSPENDED';
                            $details['paid_from'] = $dt_paid_from->format('d/m/Y');
                            $details['paid_to'] = $dt_paid_to->format('d/m/Y');
                            break;
                            
                        case MicrolearningCapsuleUser::ACCESS_CANCELLED :
                            
                            $date = date('Y-m-d');
                            if($allowCancel && $record['paid_from'] <= $date && $record['paid_to'] >= $date) {
                                $actions['link_reactive'] = $allowReactive ? $this->url()->fromRoute('microlearning/access-for-students/reactive', $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_CANCELLED';
                            $details['paid_from'] = $dt_paid_from->format('d/m/Y');
                            $details['paid_to'] = $dt_paid_to->format('d/m/Y');
                            break;
                            
                    }
                    
                    $dt_added_on = \DateTime::createFromFormat('Y-m-d H:i:s', $record['added_on']);
                    $details['added_on'] = $dt_added_on->format('d/m/Y h:i a');
                    
                    $dt_updated_on = \DateTime::createFromFormat('Y-m-d H:i:s', $record['updated_on']);
                    $details['updated_on'] = $dt_updated_on->format('d/m/Y h:i a');
                    
                    $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 {
                $topicMapper = MicrolearningTopicMapper::getInstance($this->adapter);
                $topics = $topicMapper->fetchAllByCompanyId($currentCompany->id);
                
                if($topics) {
                    $topic_id = $topics[0]->id;
                }  else {
                    $topic_id = 0;
                }
                
                
                $form = new TopicCapsuleForm($this->adapter, $currentCompany->id, $topic_id);
                $formPushNotification = new PushMicrolearningNotificationForm($this->adapter, $currentCompany->id);
                $formCapsuleCustomer = new CapsuleCustomerUploadForm();
                
                
                
                $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
                ]);
                
                return $viewModel ;
            }
            
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }
    
    
    
    
    public function revokeAction()
    {
        $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');
        $user_uuid   = $this->params()->fromRoute('user_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) {
            return new JsonModel([
                'success'   => false,
                'data'   => 'ERROR_CAPSULE_NOT_FOUND'
            ]);
        }
        
        
        if($capsule->topic_id != $topic->id) {
            return new JsonModel([
                'success'   => false,
                'data'   => 'ERROR_UNAUTHORIZED'
            ]);
        }
        
        $userMapper = UserMapper::getInstance($this->adapter);
        $user = $userMapper->fetchOneByUuid($user_uuid);
        
        if(!$user) {
            return new JsonModel([
                'success'   => false,
                'data'   => 'ERROR_USER_NOT_FOUND'
            ]);
        }
        
        $capsuleUserMapper = MicrolearningCapsuleUserMapper::getInstance($this->adapter);
        $capsuleUser = $capsuleUserMapper->fetchOneByUserIdAndCapsuleId($user->id, $capsule->id);        
        if(!$capsuleUser) {
            return new JsonModel([
                'success'   => false,
                'data'   => 'ERROR_UNAUTHORIZED'
            ]);
        }
        
        if($request->isPost()) {
           

            if($capsuleUser->access != MicrolearningCapsuleUser::ACCESS_UNLIMITED) {
                return new JsonModel([
                    'success'   => false,
                    'data'   => 'ERROR_USER_ACCESS_CANNT_BE_REVOKE'
                ]);
            }
            $capsuleUser->access = MicrolearningCapsuleUser::ACCESS_REVOKE;
            if($capsuleUserMapper->update($capsuleUser)) { 
                
                $capsuleUser = $capsuleUserMapper->fetchOne($capsuleUser->id);
                if($capsuleUser) {
                    $microlearningUserMapper = MicrolearningUserMapper::getInstance($this->adapter);
                    $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;
                        $microlearningUser->updated_on = $capsuleUser->updated_on;
                        
                        $microlearningUserMapper->insert($microlearningUser);
                    }
                }
                
                return new JsonModel([
                    'success' => true,
                    'data' => 'LABEL_USER_ACCESS_HAS_BEEN_REVOKE'
                ]);  
                
            } else {
                
                return new JsonModel([
                    'success'   => false,
                    'data'      => $capsuleUserMapper->getError()
                ]);
            }
        }
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    
    public function unlimitAction()
    {
        $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');
        $user_uuid   = $this->params()->fromRoute('user_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) {
            return new JsonModel([
                'success'   => false,
                'data'   => 'ERROR_CAPSULE_NOT_FOUND'
            ]);
        }
        
        
        if($capsule->topic_id != $topic->id) {
            return new JsonModel([
                'success'   => false,
                'data'   => 'ERROR_UNAUTHORIZED'
            ]);
        }
        
        $userMapper = UserMapper::getInstance($this->adapter);
        $user = $userMapper->fetchOneByUuid($user_uuid);
        
        if(!$user) {
            return new JsonModel([
                'success'   => false,
                'data'   => 'ERROR_USER_NOT_FOUND'
            ]);
        }
        
        $capsuleUserMapper = MicrolearningCapsuleUserMapper::getInstance($this->adapter);
        $capsuleUser = $capsuleUserMapper->fetchOneByUserIdAndCapsuleId($user->id, $capsule->id);
        if(!$capsuleUser) {
            return new JsonModel([
                'success'   => false,
                'data'   => 'ERROR_UNAUTHORIZED'
            ]);
        }
        
        if($request->isPost()) {
            
            
            if($capsuleUser->access != MicrolearningCapsuleUser::ACCESS_REVOKE) {
                return new JsonModel([
                    'success'   => false,
                    'data'   => 'ERROR_USER_ACCESS_CANNT_BE_UNLIMIT'
                ]);
            }
            $capsuleUser->access = MicrolearningCapsuleUser::ACCESS_UNLIMITED;
            if($capsuleUserMapper->update($capsuleUser)) {
                
                $capsuleUser = $capsuleUserMapper->fetchOne($capsuleUser->id);
                if($capsuleUser) {
                    $microlearningUserMapper = MicrolearningUserMapper::getInstance($this->adapter);
                    $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;
                        $microlearningUser->updated_on = $capsuleUser->updated_on;
                        
                        $microlearningUserMapper->insert($microlearningUser);
                    }
                }
                
                return new JsonModel([
                    'success' => true,
                    'data' => 'LABEL_USER_ACCESS_HAS_BEEN_UNLIMITED'
                ]);
                
            } else {
                
                return new JsonModel([
                    'success'   => false,
                    'data'      => $capsuleUserMapper->getError()
                ]);
            }
        }
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    
    public function uploadAction()
    {
        $request = $this->getRequest();
        
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser    = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();
        
        $currentNetworkPlugin = $this->plugin('currentNetworkPlugin');
        $currentNetwork = $currentNetworkPlugin->getNetwork();
        
        $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) {
            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') {
               
                
                $userMapper = UserMapper::getInstance($this->adapter);
                $capsuleUserMapper = MicrolearningCapsuleUserMapper::getInstance($this->adapter);

                $form = new  CapsuleCustomerUploadForm();
                $dataPost = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());
                
                $form->setData($dataPost);
                
                if($form->isValid()) {
                    
                    $file = $_FILES['file'];
                    $tmp_filename = $file['tmp_name'];
                    $final_filename =  'data/' . $file['name'];
                    
                    if(!move_uploaded_file($tmp_filename, $final_filename)) {
                        return new JsonModel([
                            'success' => false,
                            'data' => 'ERROR_UPLOAD_FILE'
                        ]);
                    }
                    
                   
                    $count_users = 0;
                    $users = [];
                    $count_errors = 0;
                    $errors = [];
                    
                    
                    $spreadsheet = IOFactory::load($final_filename);
                    $records = $spreadsheet->getActiveSheet()->toArray(null, true, true, true);
                    
                    $emails = [];
                    $row = 0;
                    
                    foreach($records as $record)
                    {
                        /*
                        A = Nombre      
                        B = Apellido    
                        C = Email       
                        D = Contraseña 
                        E = Empresa     
                        F = Función    
                        G = Grupo       
                        H = Institución        
                        I = Programa    
                        J = Socio       
                        K = Sector      
                        L = Tipo de Estudiante  
                        M = País       
                        N = Es adulto
                        */
                        $row++;
                        
                        
                        $first_name = Functions::sanitizeFilterString($record['A']);
                        $last_name = Functions::sanitizeFilterString($record['B']);
                        $email = trim(filter_var($record['C'], FILTER_SANITIZE_EMAIL));
                        $password = Functions::sanitizeFilterString($record['D']);
                        
                        $company =  isset($record['E']) ? Functions::sanitizeFilterString($record['E']) : '';
                        $function = isset($record['F']) ? Functions::sanitizeFilterString($record['F']) : '';
                        $group = isset($record['G']) ? Functions::sanitizeFilterString($record['G']) : '';
                        $institution = isset($record['H']) ? Functions::sanitizeFilterString($record['H']) : '';
                        $program = isset($record['I']) ? Functions::sanitizeFilterString($record['I']) : '';
                        $partner = isset($record['J']) ? Functions::sanitizeFilterString($record['J']) : '';
                        $sector = isset($record['K']) ? Functions::sanitizeFilterString($record['K']) : '';
                        $studentType = isset($record['L']) ? Functions::sanitizeFilterString($record['L']) : '';
                        $country =  isset($record['M']) ? Functions::sanitizeFilterString($record['M']) : '';
                        $isAdult = isset($record['N']) ? Functions::sanitizeFilterString($record['N']) : '';

                        
                        if($row == 1) {
                            continue;
                        }
                        
                        //||  empty($password)
                        if(empty($first_name) || empty($last_name) || !filter_var($email, FILTER_VALIDATE_EMAIL) ) {
                           
                            
                            
                            continue;
                            
                        }
                        
                        if(!in_array($email, $emails)) {
                            
                            $user = $userMapper->fetchOneByEmail($email);
                            if($user) {
                                $assigned_capsules =  $capsuleUserMapper->fetchCountByCompanyIdAndTopicIdAndUserId($topic->company_id, $topic->id, $user->id);
                            } else {
                                $assigned_capsules = 0;
                            }
                            
                            $count_users++;
                            
                            array_push($emails, $email);
                            array_push($users, [
                                'id' => $count_users,
                                'first_name' => $first_name,
                                'last_name' => $last_name,
                                'password'  => $password,
                                'email' => $email,
                                'assigned_capsules' => $assigned_capsules, 
                                'company' => $company, 
                                'function' => $function, 
                                'group' => $group, 
                                'institution' => $institution, 
                                'program' => $program,
                                'partner' => $partner,
                                'sector' => $sector, 
                                'studentType' => $studentType,
                                'country' => $country,
                                'isAdult' => $isAdult,
                            ]);
                        } else {
                            $count_errors++;
                            array_push($errors,[
                                'id' => $count_errors,
                                'first_name' => $first_name,
                                'last_name' => $last_name,
                                'password'  => $password,
                                'email' => $email,
                                'status' => 'DUPLICATE IN EXCEL'
                            ]);
                        }
                        
                        
                        
                        
                        
                    }

                    
                    $key = md5($currentUser->id . '-' . $topic->uuid . '-' . $capsule->uuid);
                    $this->cache->setItem($key, serialize($users));
                    
                    return new JsonModel([
                        'success' => true,
                        'data' => [
                            'key' => $key,
                            'topic' => $topic->name,
                            'capsule' => $capsule->name,
                            'items' => [
                                'ok' => $users,
                                'error' => $errors,
                            ],     
                        ]
                    ]);
                    
                    
                    
                } 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 if($step == 'process') {
            
                $key = Functions::sanitizeFilterString($this->params()->fromPost('key')); 
                if(!$key) {
                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_CACHE_KEY_EMPTY'
                    ]); 
                }
                
                $value = $this->cache->getItem($key);
                if(!$value) {
                    
                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_CACHE_NOT_FOUND'
                    ]); 
                }
                
                $records = unserialize($value);
                if(!$records) {
                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_CACHE_INVALID'
                    ]);
                }
                
            
                
                
                $networkMapper = NetworkMapper::getInstance($this->adapter);
                $companyMapper = CompanyMapper::getInstance($this->adapter);
                $companyFollowerMapper = CompanyFollowerMapper::getInstance($this->adapter);
                
                $connectionMapper = ConnectionMapper::getInstance($this->adapter);
                $userMapper = UserMapper::getInstance($this->adapter);
                $userPasswordMapper = UserPasswordMapper::getInstance($this->adapter);
                $capsuleUserMapper = MicrolearningCapsuleUserMapper::getInstance($this->adapter);
                
                $microlearningExtendUserMapper = MicrolearningExtendUserMapper::getInstance($this->adapter);
                $microlearningExtendUserCompanyMapper = MicrolearningExtendUserCompanyMapper::getInstance($this->adapter);
                $microlearningExtendUserFunctionMapper = MicrolearningExtendUserFunctionMapper::getInstance($this->adapter);
                $microlearningExtendUserGroupMapper = MicrolearningExtendUserGroupMapper::getInstance($this->adapter);
                $microlearningExtendUserInstitutionMapper = MicrolearningExtendUserInstitutionMapper::getInstance($this->adapter);
                $microlearningExtendUserProgramMapper = MicrolearningExtendUserProgramMapper::getInstance($this->adapter);
                $microlearningExtendUserPartnerMapper = MicrolearningExtendUserPartnerMapper::getInstance($this->adapter);
                $microlearningExtendUserSectorMapper = MicrolearningExtendUserSectorMapper::getInstance($this->adapter);
                $microlearningExtendUserStudentTypeMapper = MicrolearningExtendUserStudentTypeMapper::getInstance($this->adapter);
                $microlearningExtendUserCountryMapper = MicrolearningExtendUserCountryMapper::getInstance($this->adapter);
 
                
                $networkDefault = $networkMapper->fetchOneByDefault();
                $userDefaultForConnection = $userMapper->fetchOneDefaultForConnection();
                
                $companyForFollower = $companyMapper->fetchOneDefaultForFollowers();
                
                $csv = "FIRST NAME|LAST NAME|EMAIL|STATUS\r\n";
                
           
                $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'];
                    $email = $record['email'];
                    
                    
                    $company = $record['company'];
                    $function = $record['function'];
                    $group = $record['group'];
                    $institution = $record['institution'];
                    $program = $record['program'];
                    $partner = $record['partner'];
                    $sector = $record['sector'];
                    $studentType = $record['studentType'];
                    $country = $record['country'];
                    $isAdult = strtolower(trim( $record['isAdult'])) == User::IS_ADULT_YES;
    
    
                    $user = $userMapper->fetchOneByEmail($email);
                    if(!$user) {
                        
                        
                        if($password) {
                            $password_hash = password_hash($password, PASSWORD_DEFAULT);
                            
                            $user = new User();
                            
                            $user->network_id = $currentNetwork->id;
                            $user->blocked = User::BLOCKED_NO;
                            $user->email_verified = User::EMAIL_VERIFIED_YES;
                            $user->email = $email;
                            $user->first_name = $first_name;
                            $user->last_name = $last_name;
                            $user->password = $password_hash;
                            $user->login_attempt = 0;
                            $user->usertype_id = UserType::USER;
                            $user->status = User::STATUS_ACTIVE;
                            $user->is_adult = $isAdult ? User::IS_ADULT_YES : User::IS_ADULT_NO;
                            
                            $result = $userMapper->insert($user);
                            if($result) {
                                $userPassword = new UserPassword();
                                $userPassword->user_id = $user->id;
                                $userPassword->password = $password_hash;
                                $userPasswordMapper->insert($userPassword);
                                
                                
                                $csv .= "$first_name|$last_name|$email|CREATE USER \r\n";
                            } else {
                                $csv .= "$first_name|$last_name|$email|FAIL CREATE USER \r\n";
                                
                                continue;
                            } 
                            
                        }
                    } else {
                        $user->is_adult = $isAdult ? User::IS_ADULT_YES : User::IS_ADULT_NO;
                        if($user->email_verified == User::EMAIL_VERIFIED_NO || $user->status != User::STATUS_ACTIVE) {
                            $user->email_verified = User::EMAIL_VERIFIED_YES;
                            $user->status != User::STATUS_ACTIVE;
                            
                            
                        }
                        if(!$userMapper->update($user)) {
                            $csv .= "$first_name|$last_name|$email|FAIL UPDATE USER \r\n";
                            continue;
                        }
                            
                        
                    }
                    
      
                    $user_id_in_default_network = 0;
                    if($user->is_adult == User::IS_ADULT_YES) {
                        
                        if($currentNetwork->default == Network::DEFAULT_YES) {
                            
                            $user_id_in_default_network = $user->id;
                            
                            
                            
                        } else {
                            
                            $userInDefaultNetwork = $userMapper->fetchOneByEmailAndNetworkId($user->email, $networkDefault->id);
                            if($userInDefaultNetwork) {
                                $user_id_in_default_network = $userInDefaultNetwork->id;
                         
                                if($userInDefaultNetwork->email_verified == User::EMAIL_VERIFIED_NO || $userInDefaultNetwork->status != User::STATUS_ACTIVE) {
                                    $userInDefaultNetwork->email_verified = User::EMAIL_VERIFIED_YES;
                                    $userInDefaultNetwork->status != User::STATUS_ACTIVE;
                                    
                                    if(!$userMapper->update($userInDefaultNetwork)) {
                                        $csv .= "$first_name|$last_name|$email|FAIL UPDATE USER IN DEFAULT NETWORK \r\n";
                                        continue;
                                    }
                                }
                                
                                
                            } else {
                                $userInDefaultNetwork = new User();
                                $userInDefaultNetwork->network_id = $networkDefault->id;
                                $userInDefaultNetwork->blocked = User::BLOCKED_NO;
                                $userInDefaultNetwork->email_verified = User::EMAIL_VERIFIED_YES;
                                $userInDefaultNetwork->email = $email;
                                $userInDefaultNetwork->first_name = $first_name;
                                $userInDefaultNetwork->last_name = $last_name;
                                $userInDefaultNetwork->password = $password_hash;
                                $userInDefaultNetwork->login_attempt = 0;
                                $userInDefaultNetwork->usertype_id = UserType::USER;
                                $userInDefaultNetwork->status = User::STATUS_ACTIVE;
                                $userInDefaultNetwork->is_adult = $isAdult == User::IS_ADULT_YES;
                                $result = $userMapper->insert($userInDefaultNetwork);
                                if($result) {
                                    $user_id_in_default_network = $userInDefaultNetwork->id;
                                    
                                    
                                    $userPassword = new UserPassword();
                                    $userPassword->user_id = $userInDefaultNetwork->id;
                                    $userPassword->password = $password_hash;
                                    $userPasswordMapper->insert($userPassword);
                                    
                                    $csv .= "$first_name|$last_name|$email|CREATE USER IN DEFAULT NETWORK \r\n";
                                } else {
                                    $csv .= "$first_name|$last_name|$email|FAIL CREATE USER IN DEFAULT NETWORK \r\n";
                                }
                                
                            }
                            
                            
                        }
                    }
     
                    if($user_id_in_default_network) {
                        
                        if($userDefaultForConnection) {
                        
                            $connection = $connectionMapper->fetchOneByUserId1AndUserId2($userDefaultForConnection->id, $user_id_in_default_network);
                            if($connection) {
                                if($connection->status != Connection::STATUS_ACCEPTED) {
                                    $connection->status = Connection::STATUS_ACCEPTED;
                                    $connectionMapper->update($connection);
                                    
                                }
                                
                                
                            } else {
                                $connection = new Connection();
                                $connection->request_to = $user_id_in_default_network;
                                $connection->request_from = $userDefaultForConnection->id;
                                $connection->status = Connection::STATUS_ACCEPTED;
                                $connectionMapper->insert($connection);
                            }
                        }
                        
                        if($companyForFollower) {
                            $companyFollower = $companyFollowerMapper->fetchOneByCompanyIdAndUserId($companyForFollower->id, $user_id_in_default_network);
                            if(!$companyFollower) {
                                $companyFollower = new CompanyFollower();
                                $companyFollower->company_id = $companyForFollower->id;
                                $companyFollower->follower_id = $user_id_in_default_network;
                                
                                $companyFollowerMapper->insert($companyFollower);
                                
                                
                            }
                        }
                        
                        
                    }
                        
                    
                    if(!in_array($user->id, $user_ids)) {
                        array_push($user_ids, $user->id);
                    }
                    
                    /*
                    echo '$filterCompany = ' . $filterCompany . PHP_EOL;
                    echo '$filterFunctio = ' . $filterFunction . PHP_EOL;
                    echo '$filterGroup = ' . $filterGroup . PHP_EOL;
                    echo '$filterInstitution = ' . $filterInstitution . PHP_EOL;
                    echo '$filterPartner = ' . $filterPartner . PHP_EOL;
                    echo '$filterProgram = ' . $filterProgram . PHP_EOL;
                    echo '$filterSector = ' . $filterSector . PHP_EOL;
                    echo '$filterStudentType = ' . $filterStudentType . PHP_EOL;
                  */
                   
                    
                    $extendUser = $microlearningExtendUserMapper->fetchOneByCompanyIdAndUserId($currentCompany->id, $user->id);
                    if(!$extendUser) {
                        $extendUser = new MicrolearningExtendUser();
                        $extendUser->company_id = $currentCompany->id;
                        $extendUser->user_id = $user->id;
                    }
                    
                    
                    if($company) {
                        $record = $microlearningExtendUserCompanyMapper->fetchOneByCompanyIdAndName($currentCompany->id, $company);
      
                        if(!$record) {
                            $record = new MicrolearningExtendUserCompany();
                            $record->company_id = $currentCompany->id;
                            $record->name = $company;
                                    
                            $microlearningExtendUserCompanyMapper->insert($record);
                        }
                    

                        
                                
                        if($record->id) {
                            $extendUser->extend_company_id = $record->id;
                        }
                    }
                            
                    if($function) {
                        $record = $microlearningExtendUserFunctionMapper->fetchOneByCompanyIdAndName($currentCompany->id, $function);
                        if(!$record) {
                            $record = new MicrolearningExtendUserFunction();
                            $record->company_id = $currentCompany->id;
                            $record->name = $function;
                                    
                            $microlearningExtendUserFunctionMapper->insert($record);
                        }
                                
                        if($record->id) {
                            $extendUser->extend_function_id = $record->id;
                        }
                    }
                            
                    if($group) {
                        $record = $microlearningExtendUserGroupMapper->fetchOneByCompanyIdAndName($currentCompany->id, $group);
                        if(!$record) {
                            $record = new MicrolearningExtendUserGroup();
                            $record->company_id = $currentCompany->id;
                            $record->name = $group;
                                    
                            $microlearningExtendUserGroupMapper->insert($record);
                        }
                                
                        if($record->id) {
                            $extendUser->extend_group_id = $record->id;
                        }
                    }
                            
                    if($institution) {
                        $record = $microlearningExtendUserInstitutionMapper->fetchOneByCompanyIdAndName($currentCompany->id, $institution);
                        if(!$record) {
                            $record = new MicrolearningExtendUserInstitution();
                            $record->company_id = $currentCompany->id;
                            $record->name = $institution;
                                    
                            $microlearningExtendUserInstitutionMapper->insert($record);
                        }
                                
                        if($record->id) {
                            $extendUser->extend_institution_id = $record->id;
                        }
                    }
                            
                    if($program) {
                        $record = $microlearningExtendUserProgramMapper->fetchOneByCompanyIdAndName($currentCompany->id, $program);
                        if(!$record) {
                            $record = new MicrolearningExtendUserProgram();
                            $record->company_id = $currentCompany->id;
                            $record->name = $program;
                                    
                            $microlearningExtendUserProgramMapper->insert($record);
                        }
                                
                        if($record->id) {
                            $extendUser->extend_program_id = $record->id;
                        }
                    }
                            
                    if($partner) {
                        
                   
                        $record = $microlearningExtendUserPartnerMapper->fetchOneByCompanyIdAndName($currentCompany->id, $partner);
                        if(!$record) {
                            $record = new MicrolearningExtendUserPartner();
                            $record->company_id = $currentCompany->id;
                            $record->name = $partner;
                                    
                            $microlearningExtendUserPartnerMapper->insert($record);
                        }
                                
                        if($record->id) {
                            $extendUser->extend_partner_id = $record->id;
                        }
                    }
                            
                    if($sector) {
                        $record = $microlearningExtendUserSectorMapper->fetchOneByCompanyIdAndName($currentCompany->id, $sector);
                        if(!$record) {
                            $record = new MicrolearningExtendUserSector();
                            $record->company_id = $currentCompany->id;
                            $record->name = $sector;
                                    
                            $microlearningExtendUserSectorMapper->insert($record);
                        }
                                
                        if($record->id) {
                            $extendUser->extend_sector_id = $record->id;
                        }
                    }
                            
                    if($studentType) {
                        $record = $microlearningExtendUserStudentTypeMapper->fetchOneByCompanyIdAndName($currentCompany->id, $studentType);
                        if(!$record) {
                            $record = new MicrolearningExtendUserStudentType();
                            $record->company_id = $currentCompany->id;
                            $record->name = $studentType;
                                    
                            $microlearningExtendUserStudentTypeMapper->insert($record);
                        }
                        if($record->id) {
                            $extendUser->extend_student_type_id = $record->id;
                        }
                    }
                    
                    if($country) {
                        $record = $microlearningExtendUserCountryMapper->fetchOneByCompanyIdAndName($currentCompany->id, $country);
                        if(!$record) {
                            $record = new MicrolearningExtendUserCountry();
                            $record->company_id = $currentCompany->id;
                            $record->name = $country;
                            
                            $microlearningExtendUserCountryMapper->insert($record);
                        }
                        if($record->id) {
                            $extendUser->extend_country_id = $record->id;
                        }
                    }
                    

                    

                            
                    if($extendUser->id) {
                       $result =   $microlearningExtendUserMapper->update($extendUser);
                    } else {
                       $result = $microlearningExtendUserMapper->insert($extendUser);
                    }
                
                
                   
                }
                
                $notificationMapper = NotificationMapper::getInstance($this->adapter);
                
                
                $users_processed = 0;
                $users_previous = 0;
                foreach($user_ids as $user_id)
                {
                    $user = $userMapper->fetchOne($user_id);
                    $first_name = $user->first_name;
                    $last_name = $user->last_name;
                    $email = $user->email;
                    
                    
                    $users_processed++;
                    $capsuleUser = $capsuleUserMapper->fetchOneByUserIdAndCapsuleId($user_id, $capsule->id);
                    if($capsuleUser) {
                        $users_previous++;
                        $csv .= "$first_name|$last_name|$email|PREVIOUS FOUND \r\n";
                    } else {
                        $capsuleUser = new MicrolearningCapsuleUser();
                        $capsuleUser->company_id = $capsule->company_id;
                        $capsuleUser->topic_id = $capsule->topic_id;
                        $capsuleUser->capsule_id = $capsule->id;
                        $capsuleUser->user_id = $user_id;
                        $capsuleUser->access = MicrolearningCapsuleUser::ACCESS_UNLIMITED;
                        
                        if($capsuleUserMapper->insert($capsuleUser)) {
                            
                            $notification = new Notification();
                            $notification->company_id = $capsule->company_id;
                            $notification->user_id = $user_id;
                            $notification->topic_id = $capsule->topic_id;
                            $notification->capsule_id = $capsule->id;
                            $notification->type = Notification::TYPE_NEW_MICROLEARNING_CAPSULE;
                            $notification->message  = 'LABEL_NOTIFICATION_NEW_MICROLEARNING_CAPSULE' . ' : ' . $capsule->name;
                            $notification->url      = '/microlearning/capsules/' . $capsule->uuid .  '/detail';
                            
                            $notificationMapper->insert($notification);
                            
                            
                            $csv .= "$first_name|$last_name|$email|CAPSULE USER ASSIGNED\r\n";
                            $users_assigned++;  
                            
                            
                            $capsuleUser = $capsuleUserMapper->fetchOne($capsuleUser->id);
                            if($capsuleUser) {
                                $microlearningUserMapper = MicrolearningUserMapper::getInstance($this->adapter);
                                $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;
                                    $microlearningUser->updated_on = $capsuleUser->updated_on;
                                    
                                    $microlearningUserMapper->insert($microlearningUser);
                                } 
                            }
                        } else {
                            $csv .= "$first_name|$last_name|$email|CAPSULE USER PREVIOUS \r\n";
                        }
                        
                    }
                    
                 
                    
                }
                
                $users_in_the_capsule = $capsuleUserMapper->fetchCountByCompanyIdAndCapsuleId($capsule->company_id, $capsule->id);
                
                return new JsonModel([
                    'success' => true, 
                    'data' => [
                        'users_assigned' => $users_assigned, 
                        'users_processed' => $users_processed,
                        'users_in_the_capsule' => $users_in_the_capsule,
                        'users_previous' => $users_previous,
                        'csv_base64_content' => base64_encode($csv),
                        'csv_filename' => 'capsule-users-' .date('Y-m-d-h-i-s').  '.csv'
                    ]
                ]); 
                
                
                
                
            } else {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_PARAMETERS_ARE_INVALID'
                ]); 
            } 
            
            

            
        }
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    
    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) {
            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()) {
            $dataPost = $request->getPost()->toArray();
            $form = new PushMicrolearningNotificationForm($this->adapter, $currentCompany->id);
            
            $form->setData($dataPost);
            
            if($form->isValid()) {
                $customer_uuids = $this->params()->fromPost('customer_uuids');
                if(!$customer_uuids) {
                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_NOT_SELECTED_CUSTOMERS'
                    ]);
                    
                }
                
                $push_template_uuid = Functions::sanitizeFilterString($form->get('push_template_id')->getValue());
                $pushMapper = PushMapper::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'
                    ]);
                }
                
                
                
                $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);
                    if(!$capsuleUser) {
                        continue;
                    }
                    
                    
                    //$token = $deviceHistoryMapper->fetchLastDeviceTokenByApplicationIdAndUserId(Application::TWOGETSKILLS, $user->id);
                    $device = $deviceHistoryMapper->fetchLastDeviceByApplicationIdAndUserId(Application::TWOGETSKILLS, $user->id);
                    
                    
                    
                    if($device && $device->token) {
                        
                        $key = $application->key;
                        if($device->variant_id) {
                            
                            $applicationVariantMapper = ApplicationVariantMapper::getInstance($this->adapter);
                            $applicationVariant = $applicationVariantMapper->fetchOneByApplicationIdAndVariantId($device->application_id, $device->variant_id);
                            if($applicationVariant) {
                                $key = $applicationVariant->key;
                            } else {
                                $applicationVariant = $applicationVariantMapper->fetchOneByApplicationIdAndDefault($device->application_id);
                                if($applicationVariant) {
                                    $key = $applicationVariant->key;
                                }
                            }
                            
                        }
                        
                        $push = new Push();
                        $push->status = Push::STATUS_PENDING;
                        $push->data = json_encode([
                            'server' => [
                                'key' => $key,
                            ],
                            'push' => [
                                'registration_ids'   => [
                                    $device->token,
                                ],
                                'notification' => [
                                    'body' =>  $pushTemplate->body,
                                    'title' => $pushTemplate->title,
                                    'vibrate' => 1,
                                    'sound' =>  1
                                ],
                                'data' => [
                                    'command' => 'content-refresh',
                                    'new_capsules' => '0',
                                ]
                            ]
                        ]);
                        
                        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'
                    ]);
                }
                
                
                
                
                
                return new JsonModel([
                    'success' => true,
                    'data' => [
                        'push_to_send' => $push_to_send,
                    ]
                ]);
                
                
                
                
                
            } 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'
        ]);
    }
    
    
}