Proyectos de Subversion LeadersLinked - Backend

<?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\Mapper\MicrolearningCapsuleCommentMapper;

use LeadersLinked\Library\Functions;

use LeadersLinked\Cache\CacheInterface;

use LeadersLinked\Cache\CacheImpl;

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 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();

        $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'

                        ]);

                    }

                    $users = [];

                    $spreadsheet = IOFactory::load($final_filename);

                    $records = $spreadsheet->getActiveSheet()->toArray(null, true, true, true);

                    $emails = [];

                    foreach($records as $record)

                    {

                        //A = Nombre 	B = Apellidos	C = Email 	D = contraseña

                        $email = trim(filter_var($record['C'], FILTER_SANITIZE_EMAIL));

                        $first_name = Functions::sanitizeFilterString($record['A']);

                        $last_name = Functions::sanitizeFilterString($record['B']);

                        $password = Functions::sanitizeFilterString($record['D']);

                        $filterCompany =  isset($record['E']) ? Functions::sanitizeFilterString($record['E']) : '';

                        $filterFunction = isset($record['F']) ? Functions::sanitizeFilterString($record['F']) : '';

                        $filterGroup = isset($record['G']) ? Functions::sanitizeFilterString($record['G']) : '';

                        $filterInstitution = isset($record['H']) ? Functions::sanitizeFilterString($record['H']) : '';

                        $filterProgram = isset($record['I']) ? Functions::sanitizeFilterString($record['I']) : '';

                        $filterPartner = isset($record['J']) ? Functions::sanitizeFilterString($record['J']) : '';

                        $filterSector = isset($record['K']) ? Functions::sanitizeFilterString($record['K']) : '';

                        $filterStudentType = isset($record['L']) ? Functions::sanitizeFilterString($record['L']) : '';

                        //||  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;

                            }

                            array_push($emails, $email);

                            array_push($users, [

                                'first_name' => $first_name,

                                'last_name' => $last_name,

                                'password'  => $password,

                                'email' => $email,

                                'assigned_capsules' => $assigned_capsules,

                                'filterCompany' => $filterCompany,

                                'filterFunction' => $filterFunction,

                                'filterGroup' => $filterGroup,

                                'filterInstitution' => $filterInstitution,

                                'filterProgram' => $filterProgram,

                                'filterPartner' => $filterPartner,

                                'filterSector' => $filterSector,

                                'filterStudentType' => $filterStudentType

                            ]);

                        }

                    }

                    $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' => $users,

                        ]

                    ]);

                } 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'

                    ]);

                }

                $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);

                $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'];

                    $filterCompany = $record['filterCompany'];

                    $filterFunction = $record['filterFunction'];

                    $filterGroup = $record['filterGroup'];

                    $filterInstitution = $record['filterInstitution'];

                    $filterProgram = $record['filterProgram'];

                    $filterPartner = $record['filterPartner'];

                    $filterSector = $record['filterSector'];

                    $filterStudentType = $record['filterStudentType'];

                    $user = $userMapper->fetchOneByEmail($email);

                    if(!$user) {

                        if($password) {

                            $password_hash = password_hash($password, PASSWORD_DEFAULT);

                            $user = new User();

                            $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;

                            $result = $userMapper->insert($user);

                            if($result) {

                                $userPassword = new UserPassword();

                                $userPassword->user_id = $user->id;

                                $userPassword->password = $password_hash;

                                $userPasswordMapper->insert($userPassword);

                            } else {

                                continue;

                            }

                        }

                    } else {

                        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)) {

                                continue;

                            }

                        }

                    }

                    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($filterCompany) {

                        $record = $microlearningExtendUserCompanyMapper->fetchOneByCompanyIdAndName($currentCompany->id, $filterCompany);

                        if(!$record) {

                            $record = new MicrolearningExtendUserCompany();

                            $record->company_id = $currentCompany->id;

                            $record->name = $filterCompany;

                            $microlearningExtendUserCompanyMapper->insert($record);

                        }

                        if($record->id) {

                            $extendUser->extend_company_id = $record->id;

                        }

                    }

                    if($filterFunction) {

                        $record = $microlearningExtendUserFunctionMapper->fetchOneByCompanyIdAndName($currentCompany->id, $filterFunction);

                        if(!$record) {

                            $record = new MicrolearningExtendUserFunction();

                            $record->company_id = $currentCompany->id;

                            $record->name = $filterFunction;

                            $microlearningExtendUserFunctionMapper->insert($record);

                        }

                        if($record->id) {

                            $extendUser->extend_function_id = $record->id;

                        }

                    }

                    if($filterGroup) {

                        $record = $microlearningExtendUserGroupMapper->fetchOneByCompanyIdAndName($currentCompany->id, $filterGroup);

                        if(!$record) {

                            $record = new MicrolearningExtendUserGroup();

                            $record->company_id = $currentCompany->id;

                            $record->name = $filterGroup;

                            $microlearningExtendUserGroupMapper->insert($record);

                        }

                        if($record->id) {

                            $extendUser->extend_group_id = $record->id;

                        }

                    }

                    if($filterInstitution) {

                        $record = $microlearningExtendUserInstitutionMapper->fetchOneByCompanyIdAndName($currentCompany->id, $filterInstitution);

                        if(!$record) {

                            $record = new MicrolearningExtendUserInstitution();

                            $record->company_id = $currentCompany->id;

                            $record->name = $filterInstitution;

                            $microlearningExtendUserInstitutionMapper->insert($record);

                        }

                        if($record->id) {

                            $extendUser->extend_institution_id = $record->id;

                        }

                    }

                    if($filterProgram) {

                        $record = $microlearningExtendUserProgramMapper->fetchOneByCompanyIdAndName($currentCompany->id, $filterProgram);

                        if(!$record) {

                            $record = new MicrolearningExtendUserProgram();

                            $record->company_id = $currentCompany->id;

                            $record->name = $filterProgram;

                            $microlearningExtendUserProgramMapper->insert($record);

                        }

                        if($record->id) {

                            $extendUser->extend_program_id = $record->id;

                        }

                    }

                    if($filterPartner) {

                        $record = $microlearningExtendUserPartnerMapper->fetchOneByCompanyIdAndName($currentCompany->id, $filterPartner);

                        if(!$record) {

                            $record = new MicrolearningExtendUserPartner();

                            $record->company_id = $currentCompany->id;

                            $record->name = $filterPartner;

                            $microlearningExtendUserPartnerMapper->insert($record);

                        }

                        if($record->id) {

                            $extendUser->extend_partner_id = $record->id;

                        }

                    }

                    if($filterSector) {

                        $record = $microlearningExtendUserSectorMapper->fetchOneByCompanyIdAndName($currentCompany->id, $filterSector);

                        if(!$record) {

                            $record = new MicrolearningExtendUserSector();

                            $record->company_id = $currentCompany->id;

                            $record->name = $filterSector;

                            $microlearningExtendUserSectorMapper->insert($record);

                        }

                        if($record->id) {

                            $extendUser->extend_sector_id = $record->id;

                        }

                    }

                    if($filterStudentType) {

                        $record = $microlearningExtendUserStudentTypeMapper->fetchOneByCompanyIdAndName($currentCompany->id, $filterStudentType);

                        if(!$record) {

                            $record = new MicrolearningExtendUserStudentType();

                            $record->company_id = $currentCompany->id;

                            $record->name = $filterStudentType;

                            $microlearningExtendUserStudentTypeMapper->insert($record);

                        }

                        if($record->id) {

                            $extendUser->extend_student_type_id = $record->id;

                        }

                    }

                    if($extendUser->id) {

                       $result =   $microlearningExtendUserMapper->update($extendUser);

                    } else {

                       $result = $microlearningExtendUserMapper->insert($extendUser);

                    }

                }

                foreach($user_ids as $user_id)

                {

                    $capsuleUser = $capsuleUserMapper->fetchOneByUserIdAndCapsuleId($user_id, $capsule->id);

                    if(!$capsuleUser) {

                        $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)) {

                            $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);

                                }

                            }

                        }

                    }

                }

                return new JsonModel([

                    'success' => true,

                    'data' => [

                        'users_assigned' => $users_assigned

                    ]

                ]);

            } 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);

            $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);

                    if($token) {

                        $push = new Push();

                        $push->status = Push::STATUS_PENDING;

                        $push->data = json_encode([

                            'server' => [

                                'key' =>   $application->key,

                            ],

                            'push' => [

                                'registration_ids'   => [

                                    $token,

                                ],

                                'notification' => [

                                    'body' =>  $pushTemplate->body,

                                    'title' => $pushTemplate->title,

                                    'vibrate' => 1,

                                    'sound' =>  1

                                ],

                            ]

                        ]);