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\Library\Functions;
use LeadersLinked\Mapper\UserMapper;
use LeadersLinked\Mapper\UserPasswordMapper;

use LeadersLinked\Model\User;
use LeadersLinked\Form\ChangePasswordForm;
use LeadersLinked\Model\CompanyUser;
use LeadersLinked\Mapper\CompanyUserMapper;
use LeadersLinked\Mapper\CompanyUserRoleMapper;
use LeadersLinked\Mapper\RoleMapper;
use LeadersLinked\Model\UserType;
use LeadersLinked\Model\UserPassword;
use PhpOffice\PhpSpreadsheet\IOFactory;
use LeadersLinked\Form\UserUploadForm;
use LeadersLinked\Mapper\CompanyServiceMapper;
use LeadersLinked\Model\CompanyService;
use LeadersLinked\Model\Role;
use LeadersLinked\Mapper\CompanyRoleMapper;
use LeadersLinked\Model\CompanyUserRole;
use LeadersLinked\Model\Notification;
use LeadersLinked\Model\EmailTemplate;
use LeadersLinked\Mapper\NotificationMapper;
use LeadersLinked\Mapper\UserNotificationSettingMapper;
use LeadersLinked\Mapper\EmailTemplateMapper;
use LeadersLinked\Library\QueueEmail;
use LeadersLinked\Mapper\NetworkMapper;
use LeadersLinked\Model\Network;
use LeadersLinked\Mapper\CompanyMapper;
use LeadersLinked\Mapper\ConnectionMapper;
use LeadersLinked\Model\Connection;
use LeadersLinked\Mapper\CompanyFollowerMapper;
use LeadersLinked\Model\CompanyFollower;
use LeadersLinked\Mapper\CountryMapper;
use LeadersLinked\Mapper\LocationMapper;
use LeadersLinked\Model\Location;
use LeadersLinked\Form\User\ChangeTypeForm;
use LeadersLinked\Form\User\NetworkDataForm;
use LeadersLinked\Cache\CacheInterface;
use LeadersLinked\Cache\CacheImpl;

class UserController 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();
        
        $currentNetworkPlugin = $this->plugin('currentNetworkPlugin');
        $currentNetwork = $currentNetworkPlugin->getNetwork();
        
        
        $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) {
            {
                $network_id = $this->params()->fromQuery('network_id');
                if($currentUser->is_super_user == User::IS_SUPER_USER_YES) {
                    
                    $networkMapper = NetworkMapper::getInstance($this->adapter);
                    $network = $networkMapper->fetchOneByUuid($network_id);
                    if(!$network) {
                        $network = $currentNetwork;
                    }
                } else {
                    $network = $currentNetwork;
                    
                }
                
                

                $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);
                
                $records_x_page     = intval($this->params()->fromQuery('length', 10), 10);
                $page               = (intval($this->params()->fromQuery('start', 1), 10)/$records_x_page)+1;
                
                $order =  $this->params()->fromQuery('order', []);
                $order_field        = empty($order[0]['column']) ? 99 :  intval($order[0]['column'], 10);
                $order_direction    = empty($order[0]['dir']) ? 'ASC' : strtoupper(Functions::sanitizeFilterString($order[0]['dir']));
    
                $fields =  ['first_name', 'last_name', 'email'];
                $order_field = isset($fields[$order_field]) ? $fields[$order_field] : 'first_name';
                
                if(!in_array($order_direction, ['ASC', 'DESC'])) {
                    $order_direction = 'ASC';
                }
                

                if($currentCompany) {
                    $companyUserRoleMapper = CompanyUserRoleMapper::getInstance($this->adapter);
                    
                    $roles = []; 
                    $roleMapper = RoleMapper::getInstance($this->adapter);
                    $records = $roleMapper->fetchAll(); 
                    foreach ($records as $record)
                    {
                        $roles[ $record->id ] = $record->name;
                    }
            
                    
                    //Usuarios cuando el nivel es empresa
                    
                    $acl = $this->getEvent()->getViewModel()->getVariable('acl');
                    $allowUnblock = $acl->isAllowed($currentUser->usertype_id, 'users/unblock');
                    $allowChangePassword = $acl->isAllowed($currentUser->usertype_id, 'users/change-password');
                    
                    $allowAccept    = $acl->isAllowed($currentUser->usertype_id, 'users/accept') ? 1 : 0;
                    $allowCancel    = $acl->isAllowed($currentUser->usertype_id, 'users/cancel') ? 1 : 0;
                    $allowReject    = $acl->isAllowed($currentUser->usertype_id, 'users/reject') ? 1 : 0;
                    $allowEdit     = $acl->isAllowed($currentUser->usertype_id, 'users/edit') ? 1 : 0;
                    

                    
                    $status = Functions::sanitizeFilterString($this->params()->fromQuery('status'));
                    if(!in_array($status, [
                        CompanyUser::STATUS_ACCEPTED,
                        CompanyUser::STATUS_ADMIN_WILL_ADD,
                        CompanyUser::STATUS_CANCELLED,
                        CompanyUser::STATUS_PENDING,
                        CompanyUser::STATUS_REJECTED,
                        CompanyUser::STATUS_SENT,
                    ])) { 
                        $status = '';
                    }
                    
                    
                    
                    $userMapper = UserMapper::getInstance($this->adapter);
                    $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                    
                    $paginator = $userMapper->fetchAllDataTableByCompanyId($currentCompany->id, $search, $status,   $page, $records_x_page, $order_field, $order_direction);
                    
                    $items = [];
                    $records = $paginator->getCurrentItems();
                    
                    foreach($records as $record)
                    {
                        
                        $actions = []; 
                        $actions['link_profile'] = 'https://'. $network->main_hostname . '/profile/view/' . $record['uuid'];
                        
                        
                        
                        
                        $details = []; 
                        switch ($record['status'])
                        {
                            
                            case CompanyUser::STATUS_PENDING :
                                $details['status']  = 'LABEL_PENDING';
                                $actions['link_accept'] = $allowAccept ? $this->url()->fromRoute('users/accept', ['id' => $record['uuid']]) : '';
                                $actions['link_reject'] = $allowReject ? $this->url()->fromRoute('users/reject', ['id' => $record['uuid']]) : '';
                                break;
                                
                            case CompanyUser::STATUS_ACCEPTED : 
                                $details['status']  = 'LABEL_ACCEPTED';
                                if($record['creator'] == CompanyUser::CREATOR_NO) { 
                                    $actions['link_edit'] = $allowEdit ? $this->url()->fromRoute('users/edit', ['id' => $record['uuid']]) : '';
                                    
                                    
                                    
                                    $actions['link_cancel'] = $allowCancel ? $this->url()->fromRoute('users/cancel', ['id' => $record['uuid']]) : '';
                                } 
                                
                                break;
                                
                            case CompanyUser::STATUS_ADMIN_WILL_ADD : 
                                $details['status']  = 'LABEL_ADMIN_WILL_ADD';
                                $actions['link_cancel'] = $allowCancel ? $this->url()->fromRoute('users/cancel', ['id' => $record['uuid']]) : '';
                                $actions['link_edit'] = $allowEdit ? $this->url()->fromRoute('users/edit', ['id' => $record['uuid']]) : '';
                                
                                break;
                                
                            case CompanyUser::STATUS_SENT :
                                $details['status']  = 'LABEL_INVITED';
                                $actions['link_accept'] = $allowAccept ? $this->url()->fromRoute('users/accept', ['id' => $record['uuid']]) : '';
                                $actions['link_reject'] = $allowReject ? $this->url()->fromRoute('users/reject', ['id' => $record['uuid']]) : '';
                                break;
                                
                            case CompanyUser::STATUS_REJECTED :
                                $actions['link_accept'] = $allowAccept ? $this->url()->fromRoute('users/accept', ['id' => $record['uuid']]) : '';
                                $details['status']  = 'LABEL_REJECTED';
                                break;
                                
                            case CompanyUser::STATUS_CANCELLED :
                                $actions['link_accept'] = $allowAccept ? $this->url()->fromRoute('users/accept', ['id' => $record['uuid']]) : '';
                                $details['status']  = 'LABEL_CANCELLED';
                                break;
                                
                            default : 
                                $details['status']  = '';
                                break;
                                
                        }
                        
                        $totalOtherCompanies = $companyUserMapper->fetchCountOtherCompaniesByCompanyIdAndUserId($currentCompany->id, $record['id']);
                        if(!$totalOtherCompanies) {
                        
                            $actions['link_change_password'] = $allowChangePassword ? $this->url()->fromRoute('users/change-password', ['id' => $record['uuid'] ]) : '';
                            if($record['blocked'] == User::BLOCKED_YES ) {
                                $actions['link_unblock'] = $allowUnblock ? $this->url()->fromRoute('users/unblock', ['id' => $record['uuid'] ]) : '';
                            } 
                        }
                        
                        if($record['blocked'] == User::BLOCKED_YES ) {
                            $details['blocked'] = 'LABEL_YES';
                        } else if($record['blocked'] == User::BLOCKED_NO ) {
                            $details['blocked'] = 'LABEL_NO';
                        }
                        if($record['email_verified'] == User::EMAIL_VERIFIED_YES ) {
                            $details['email_verified'] = 'LABEL_YES';
                            
                        } else if($record['email_verified'] == User::EMAIL_VERIFIED_NO ) {
                            $details['email_verified'] = 'LABEL_NO';
                        }
                        $details['login_attempt'] = $record['login_attempt'];
                        
                        
                        $company_user_roles = $companyUserRoleMapper->fetchAllByCompanyIdAndUserId($currentCompany->id, $record['id']);
                        
                        $details['roles'] = [];
                        
                        if($record['creator'] == CompanyUser::CREATOR_YES) {
                            $details['roles'][] = 'LABEL_ALL_PERMITS';
                            $details['creator'] = 'LABEL_YES' ;
                        }  else { 
                            $details['creator'] = 'LABEL_NO'; 
                            foreach($company_user_roles as $company_user_role)
                            {
                                $role = $roles[ $company_user_role->role_id ];
                                $details['roles'][] = $role;
                                
                            }
                        } 
                        
                       
                        $details['backend'] = $record['backend'] == CompanyUser::BACKEND_YES ? 'LABEL_YES' : 'LABEL_NO';
                        

                        
                        
                        
                        
                        $item = [
                            'first_name' => $record['first_name'] ,
                            'last_name' => $record['last_name'],
                            'email' => $record['email'],
                            'details' => $details,
                            'actions' =>  $actions ,
                       ];
                        
                        array_push($items, $item);
                    }
                } else {
                    //Usuario cuando el nivel es administrador
                    
          
                    
                    $acl = $this->getEvent()->getViewModel()->getVariable('acl');
                    $allowUnblock = $acl->isAllowed($currentUser->usertype_id, 'users/unblock');
                    $allowChangePassword = $acl->isAllowed($currentUser->usertype_id, 'users/change-password');
                    $allowChangeType   = $acl->isAllowed($currentUser->usertype_id, 'users/change-type') ? 1 : 0;
                    
                    
                    
                    $userMapper = UserMapper::getInstance($this->adapter);
                    $paginator = $userMapper->fetchAllDataTableByNetworkId($network->id, $search, $page, $records_x_page, $order_field, $order_direction);
                    
                    $items = [];
                    $records = $paginator->getCurrentItems();
                    
                    foreach($records as $record)
                    {
                        $actions = [];
                        
                        if($currentNetwork->id == $record->network_id) {
                        
                            $actions['link_profile'] = 'https://'. $network->main_hostname . '/profile/view/' . $record->uuid;
                        } else {
                            $actions['link_profile'] = '';
                        }
                        
                        $details = [] ;
                        if($record->status == User::STATUS_ACTIVE ) {
                            $details['status'] = 'LABEL_ACTIVE';
                        } else if($record->status == User::STATUS_INACTIVE ) {
                            $details['status'] = 'LABEL_INACTIVE';  
                        }
                        if($record->blocked == User::BLOCKED_YES ) {
                            $details['blocked'] = 'LABEL_YES';
                        } else if($record->blocked == User::BLOCKED_NO ) {
                            $details['blocked'] = 'LABEL_NO';
                        }
                        if($record->email_verified == User::EMAIL_VERIFIED_YES ) {
                            $details['email_verified'] = 'LABEL_YES';
                            
                        } else if($record->email_verified == User::EMAIL_VERIFIED_NO ) {
                            $details['email_verified'] = 'LABEL_NO';
                        }
                        
                        if($record->usertype_id == UserType::ADMIN) {
                            $details['user_type'] = 'LABEL_ADMINISTRATOR';
                        } else   if($record->usertype_id == UserType::USER) {
                            $details['user_type'] = 'LABEL_USER';
                        }
                        
                        $details['login_attempt'] = $record->login_attempt;
                        
                        
                        $actions['link_change_password'] = $allowChangePassword ? $this->url()->fromRoute('users/change-password', ['id' => $record->uuid ]) : '';
                        $actions['link_unblock'] = $allowUnblock && $record->blocked == User::BLOCKED_YES ? $this->url()->fromRoute('users/unblock', ['id' => $record->uuid ]) : '';
                        $actions['link_change_type'] =  $record->is_super_user == User::IS_SUPER_USER_NO && $allowChangeType ? $this->url()->fromRoute('users/change-type', ['id' => $record->uuid ]) : '';
                        
                        
                        $item = [
                            'first_name' => $record->first_name,
                            'last_name' => $record->last_name,
                            'email' => $record->email,
                            'details' => $details,
                            'actions' => $actions
                         ];
                        
                        array_push($items, $item);
                    }
                }
            }
            
            return new JsonModel([
                'success' => true,
                'data' => [
                    'items' => $items,
                    'total' => $paginator->getTotalItemCount(),
                ]
            ]);
                

            
        }
        else if($request->isGet()) {
            $this->layout()->setTemplate('layout/layout-backend');
            $viewModel = new ViewModel();
            
            
            $networks = [];
            $networkMapper = NetworkMapper::getInstance($this->adapter);
            
            if($currentUser->is_super_user == User::IS_SUPER_USER_YES) {
                $records = $networkMapper->fetchAll();
                foreach($records as $record) 
                {
                    $networks[ $record->uuid ] = $record->name;
                }
                
            } else {
                $networks[ $currentNetwork->uuid ] = $currentNetwork->name;
            
            }
            
            
            $formFilter = new NetworkDataForm($networks);
            $formUploadUsers = new UserUploadForm();
            $formChangePassword = new ChangePasswordForm();
            $formChangeType = new ChangeTypeForm();
            
            $company = $currentUserPlugin->getCompany();
            if($company) {
                $viewModel->setTemplate('leaders-linked/users/company.phtml');
                 
            } else { 
                $viewModel->setTemplate('leaders-linked/users/index.phtml');
            }
            $viewModel->setVariables([
                'formUploadUsers' => $formUploadUsers,
                'formChangePassword' => $formChangePassword,
                'formChangeType' => $formChangeType,
                'formFilter' => $formFilter
            ] );
            return $viewModel ;
      
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);;
        }
    }
    /*
    public function addAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $request = $this->getRequest();
        
        
        if($request->isPost()) {
            $form = new  AddForm($this->adapter);
            $dataPost = $request->getPost()->toArray();
            
            $form->setData($dataPost);
            
            if($form->isValid()) {
                $dataPost = (array) $form->getData();

                $hydrator = new ObjectPropertyHydrator();
                $user = new User();
                $hydrator->hydrate($dataPost, $user);  

                
                $userMapper = UserMapper::getInstance($this->adapter);
                $result = $userMapper->insert($user);
                
                if($result) {
                    $this->logger->info('Se agrego el usuario ' . $user->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                    
                    $data = [
                        'success'   => true,
                        'data'   => 'LABEL_RECORD_ADDED'
                    ];
                } else {
                    $data = [
                        'success'   => false,
                        'data'      => $userMapper->getError()
                    ];
                    
                }
                
                return new JsonModel($data);
                
            } else {
                $messages = [];
                $form_messages = (array) $form->getMessages();
                foreach($form_messages  as $fieldname => $field_messages)
                {
                    
                    $messages[$fieldname] = array_values($field_messages);
                }
                
                return new JsonModel([
                    'success'   => false,
                    'data'   => $messages
                ]);
            }

        } else {
            $data = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
            
            return new JsonModel($data);
        }
        
        return new JsonModel($data);
    }
    
    public function editAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $request = $this->getRequest();
        $id = $this->params()->fromRoute('id');

        
        if(!$id) {
            $data = [
                'success'   => false,
                'data'   => 'ERROR_INVALID_PARAMETER'
            ];
            
            return new JsonModel($data);
        }

        $userMapper = UserMapper::getInstance($this->adapter);
        $user = $userMapper->fetchOne($id);
        if(!$user) {
            $data = [
                'success'   => false,
                'data'   => 'ERROR_RECORD_NOT_FOUND'
            ];
            
            return new JsonModel($data);
        }
        
        if($request->isPost()) {
            $form = new  EditForm($this->adapter);
            $dataPost = $request->getPost()->toArray();
            
            $form->setData($dataPost);
            
            if($form->isValid()) {
                $dataPost = (array) $form->getData();
                
                $hydrator = new ObjectPropertyHydrator();
                $hydrator->hydrate($dataPost, $user);
                $result = $userMapper->update($user);
                
                if($result) {
                    $this->logger->info('Se actualizo el usuario ' . $user->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                    
                    $data = [
                        'success' => true,
                        'data' => 'LABEL_RECORD_UPDATED'
                    ];
                } else {
                    $data = [
                        'success'   => false,
                        'data'      => $userMapper->getError()
                    ];
                }
                
                return new JsonModel($data);
                
            } else {
                $messages = [];
                $form_messages = (array) $form->getMessages();
                foreach($form_messages  as $fieldname => $field_messages)
                {
                    $messages[$fieldname] = array_values($field_messages);
                }
                
                return new JsonModel([
                    'success'   => false,
                    'data'   => $messages
                ]);
            }
        } else if ($request->isGet()) {
            $hydrator = new ObjectPropertyHydrator();
            
            $data = [
                'success' => true,
                'data' => $hydrator->extract($user)
            ];
            
            return new JsonModel($data);
        } else {
            $data = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
            
            return new JsonModel($data);
        }
        
        return new JsonModel($data);
    }
    
    public function deleteAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $request = $this->getRequest();
        $id = $this->params()->fromRoute('id');
        
        if(!$id) {
            $data = [
                'success'   => false,
                'data'   => 'ERROR_INVALID_PARAMETER'
            ];
            
            return new JsonModel($data);
        }
        
                
        $userMapper = UserMapper::getInstance($this->adapter);
        $user = $userMapper->fetchOne($id);
        if(!$user) {
            $data = [
                'success'   => false,
                'data'   => 'ERROR_RECORD_NOT_FOUND'
            ];
            
            return new JsonModel($data);
        }
        
        if($request->isPost()) {
            $result = $userMapper->delete($user);
            if($result) {
                $this->logger->info('Se borro el usuario ' . $user->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                
                $data = [
                    'success' => true,
                    'data' => 'LABEL_RECORD_DELETED'
                ];
            } else {

                $data = [
                    'success'   => false,
                    'data'      => $userMapper->getError()
                ];

                return new JsonModel($data);
            }

        } else {
            $data = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
            
            return new JsonModel($data);
        }
        
        return new JsonModel($data);
    }*/
    
    public function unblockAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $request = $this->getRequest();

        
        if($request->isPost()) {
            
            $uuid = $this->params()->fromRoute('id');
            if(!$uuid) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_INVALID_PARAMETER'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($uuid);
            
            if(!$user) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_NOT_FOUND'
                ]);
            }
     
            if($user->blocked == User::BLOCKED_NO) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_IS_NOT_BLOCKED'
                ]);
            }


                
            $result = $userMapper->unblock($user);
            if($result) {
                $this->logger->info('El usuario : ' . $user->email . ' ha sido desbloqueado ', ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                
                return new JsonModel([
                    'success'   => true,
                    'data'      => 'LABEL_USER_HAS_BEEN_UNBLOCKED',
                ]);
            }  else {
                
                return new JsonModel([
                    'success'   => false,
                    'data'      => $userMapper->getError()
                ]);
            }
            
            
        }
        
        
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    
    public function emailVerifyAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $request = $this->getRequest();
        
        
        if($request->isPost()) {
            
            $uuid = $this->params()->fromRoute('id');
            if(!$uuid) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_INVALID_PARAMETER'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($uuid);
            
            if(!$user) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
            if($user->blocked == User::BLOCKED_NO) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_IS_NOT_PENDING_FOR_EMAIL_VERIFY'
                ]);
            }
            
            
            
            $result = $userMapper->emailVerifyAndActive($user);
            if($result) {
                $this->logger->info('El usuario : ' . $user->email . ' ha sido desbloqueado ', ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                
                return new JsonModel([
                    'success'   => true,
                    'data'      => 'LABEL_USER_HAS_BEEN_UNBLOCKED',
                ]);
            }  else {
                
                return new JsonModel([
                    'success'   => false,
                    'data'      => $userMapper->getError()
                ]);
            }
            
            
        }
        
        
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    
    public function changePasswordAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $request = $this->getRequest();

        if($request->isGet()) {
            $uuid = $this->params()->fromRoute('id');
            if(!$uuid) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_INVALID_PARAMETER'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($uuid);
            
            
            
            if($user) {
                return new JsonModel([
                    'success'   => true,
                    'data'      => [
                        'first_name' => $user->first_name,
                        'last_name' => $user->last_name,
                        'email' => $user->email,
                    ]
                ]);
            } else {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
        }
        
        if($request->isPost()) {
            
            $uuid = $this->params()->fromRoute('id');
            if(!$uuid) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_INVALID_PARAMETER'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($uuid);
            
            if(!$user) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
            
            $dataPost = $request->getPost()->toArray();
            $form = new ChangePasswordForm();
            $form->setData($dataPost);
            
            if($form->isValid()) {
                
                
                
                $data = (array) $form->getData();
                $password = $data['password'];
                

                
                $userPasswordMapper = UserPasswordMapper::getInstance($this->adapter);
                $userPasswords = $userPasswordMapper->fetchAllByUserId($user->id);
                
                $oldPassword = false;
                foreach($userPasswords as $userPassword)
                {
                    if(password_verify($password, $userPassword->password) || (md5($password) == $userPassword->password))
                    {
                        $oldPassword = true;
                        break;
                    }
                }
                
                if($oldPassword) {
                    $this->logger->err('Cambio de contraseña del usuario - error contraseña ya utilizada anteriormente', ['user_id' =>  $currentUser->id, 'ip' => Functions::getUserIP()]);
                    
                    return new JsonModel([
                        'success'   => false,
                        'data'      => 'ERROR_PASSWORD_HAS_ALREADY_BEEN_USED'
                        
                    ]);
                } else {
                    $password_hash = password_hash($password, PASSWORD_DEFAULT);
                    
                    
                    $result = $userMapper->updatePassword($user, $password_hash);
                    if($result) {
                        $this->logger->info('Cambio de contraseña del usuario realizado', ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                        
                        
                        return new JsonModel([
                            'success'   => true,
                            'data'      => 'LABEL_YOUR_PASSWORD_HAS_BEEN_UPDATED'
                            
                        ]);
                    } else {
                        $this->logger->err('Cambio de contraseña del usuario - error desconocido', ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                        
                        return new JsonModel([
                            'success'   => true,
                            'data'      => 'ERROR_THERE_WAS_AN_ERROR'
                            
                        ]);
                    }
                }
                
            } else {
                $messages = [];
                
                $form_messages = (array) $form->getMessages();
                foreach($form_messages  as $fieldname => $field_messages)
                {
                    $messages[$fieldname] = array_values($field_messages);
                }
                
                return new JsonModel([
                    'success'   => false,
                    'data'   => $messages
                ]);
            }
            
        }
        
        
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    
    public function cancelAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $currentCompany = $currentUserPlugin->getCompany(); 
        
        $request = $this->getRequest();
        
        
        if($request->isPost()) {
            
            $uuid = $this->params()->fromRoute('id');
            if(!$uuid) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_INVALID_PARAMETER'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($uuid);
            
            if(!$user) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_COMPANY_NOT_FOUND'
                ]);
            }
            
            $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
            $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($currentCompany->id, $user->id); 
            
            if(!$companyUser) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
            
            if(!in_array($companyUser->status, [  CompanyUser::STATUS_ADMIN_WILL_ADD, CompanyUser::STATUS_ACCEPTED])) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_COMPANY_WRONG_STATUS'
                ]);
            }
            
            $companyUser->status = CompanyUser::STATUS_CANCELLED;
            $result = $companyUserMapper->update($companyUser);
            if($result) {
                $this->logger->info('La relación del usuario : ' . $user->email . ' con la empresa : ' . $currentCompany->name  . ' ha sido cancelada ', ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                
                return new JsonModel([
                    'success'   => true,
                    'data'      => 'LABEL_USER_COMPANY_HAS_BEEN_CANCELLED',
                ]);
            }  else {
                
                return new JsonModel([
                    'success'   => false,
                    'data'      => $userMapper->getError()
                ]);
            }
            
            
        }
        
        
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    
    public function acceptAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $currentCompany = $currentUserPlugin->getCompany();
        
        $request = $this->getRequest();
        
        
        if($request->isPost()) {
            
            $uuid = $this->params()->fromRoute('id');
            if(!$uuid) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_INVALID_PARAMETER'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($uuid);
            
            if(!$user) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
            $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
            $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($currentCompany->id, $user->id);
            
            if(!$companyUser) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
            if($companyUser->status != CompanyUser::STATUS_PENDING
                && $companyUser->status != CompanyUser::STATUS_SENT
                && $companyUser->status != CompanyUser::STATUS_CANCELLED
                && $companyUser->status != CompanyUser::STATUS_REJECTED) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_COMPANY_WRONG_STATUS'
                ]);
            }
            
            $companyUser->status = CompanyUser::STATUS_ACCEPTED;
            $result = $companyUserMapper->update($companyUser);
            if($result) {
                $this->logger->info('La relación del usuario : ' . $user->email . ' con la empresa : ' . $currentCompany->name  . ' ha sido aceptada ', ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                
                return new JsonModel([
                    'success'   => true,
                    'data'      => 'LABEL_USER_COMPANY_HAS_BEEN_ACCEPTED'
                ]);
            }  else {
                
                return new JsonModel([
                    'success'   => false,
                    'data'      => $userMapper->getError()
                ]);
            }
            
            
        }
        
        
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    
    public function rejectAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $currentCompany = $currentUserPlugin->getCompany();
        
        $request = $this->getRequest();
        
        
        if($request->isPost()) {
            
            $uuid = $this->params()->fromRoute('id');
            if(!$uuid) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_INVALID_PARAMETER'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($uuid);
            
            if(!$user) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
            $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
            $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($currentCompany->id, $user->id);
            
            if(!$companyUser) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_COMPANY_NOT_FOUND'
                ]);
            }
            
            if($companyUser->status != CompanyUser::STATUS_PENDING 
                && $companyUser->status != CompanyUser::STATUS_SENT) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_COMPANY_WRONG_STATUS'
                ]);
            }
            
            $companyUser->status = CompanyUser::STATUS_REJECTED;
            $result = $companyUserMapper->update($companyUser);
            if($result) {
                $this->logger->info('La relación del usuario : ' . $user->email . ' con la empresa : ' . $currentCompany->name  . ' ha sido rechazada ', ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                
                return new JsonModel([
                    'success'   => true,
                    'data'      => 'LABEL_USER_COMPANY_HAS_BEEN_REJECTED',
                ]);
            }  else {
                
                return new JsonModel([
                    'success'   => false,
                    'data'      => $userMapper->getError()
                ]);
            }
            
            
        }
        
        
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    
    public function inviteAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        
        
        $currentCompany = $currentUserPlugin->getCompany();
        
        $request = $this->getRequest();
        
        if($request->isGet()) {
            
            $search = Functions::sanitizeFilterString($this->params()->fromQuery('search')) ;
            if(strlen($search) >= 3) {
                
                $userMapper = UserMapper::getInstance($this->adapter);
                $records  = $userMapper->fetchAllSuggestForInvitationByCompanyId($currentCompany->id, $search);
                
                $users = []; 
                foreach($records as $record)
                {
                    array_push($users, [
                        'value' => $record->uuid, 
                        'text' => trim($record->first_name . ' ' . $record->last_name) . ' (' . $record->email . ')' 
                        
                    ]);
                }
                
                return new JsonModel([
                    'success' => true,
                    'data' => $users
                ]);
                
             
                
                
            } else {
                return new JsonModel([
                    'success' => true,
                    'data' => [
                        
                    ]
                ]); 
            } 
            
            
            
            
            
            
        } else if($request->isPost()) {
            
            $uuid = $this->params()->fromPost('id');
            if(!$uuid) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_INVALID_PARAMETER'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($uuid);
            
            if(!$user) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
            if($user->status != User::STATUS_ACTIVE) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_IS_INACTIVE'
                ]);
            }
            
            
            
            
            
            $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
            $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($currentCompany->id, $user->id);
            
            if($companyUser && $companyUser->status == CompanyUser::STATUS_ACCEPTED) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_COMPANY_FOUND'
                ]);
            }
            $networkMapper = NetworkMapper::getInstance($this->adapter);
            $network = $networkMapper->fetchOne($currentUser->network_id);

            
            if($companyUser) {
                
                
                if($network->default == Network::DEFAULT_YES) {
                    $companyUser->status = CompanyUser::STATUS_ADMIN_WILL_ADD;
                } else {
                    $companyUser->status = CompanyUser::STATUS_ACCEPTED;
                }
                $result = $companyUserMapper->update($companyUser);
                
            } else {

                
                $companyUser = new CompanyUser();
                $companyUser->company_id = $currentCompany->id;
                $companyUser->backend = CompanyUser::BACKEND_NO;
                $companyUser->creator = CompanyUser::CREATOR_NO;
                $companyUser->owner = CompanyUser::OWNER_NO;
                
                if($network->default == Network::DEFAULT_YES) {
                    $companyUser->status = CompanyUser::STATUS_ADMIN_WILL_ADD;
                } else {
                    $companyUser->status = CompanyUser::STATUS_ACCEPTED;
                }
                
                
                $companyUser->status = CompanyUser::STATUS_ADMIN_WILL_ADD;
                $companyUser->user_id = $user->id;
                
                
                
                $result = $companyUserMapper->insert($companyUser);
            }
           
  
            
            if($result) {

                
                $notification = new Notification();
                $notification->type     = Notification::TYPE_RECEIVE_INVITATION_COMPANY;
                $notification->read     = Notification::NO;
                $notification->user_id  = $user->id;
                $notification->company_id = $currentCompany->id;
                $notification->message  = 'LABEL_NOTIFICATION_RECEIVE_INVITATION_COMPANY';
                $notification->url      = 'company/view/' . $currentCompany->uuid;
                
                $notificationMapper = NotificationMapper::getInstance($this->adapter);
                $notificationMapper->insert($notification);
                
                $userNotificationMapper = UserNotificationSettingMapper::getInstance($this->adapter);
                $userNotification = $userNotificationMapper->fetchOne($user->id);
                
                if($userNotification && $userNotification->receive_invitation_company)
                {
                    $emailTemplateMapper = EmailTemplateMapper::getInstance($this->adapter);
                    $emailTemplate = $emailTemplateMapper->fetchOneByCodeAndNetworkId(EmailTemplate::CODE_RECEIVE_INVITATION_COMPANY, $currentUser->network_id);
                    
                    if($emailTemplate) 
                    {
                        $company_profile_url = 'https://'. $network->main_hostname . '/company/view/' . $currentCompany->uuid;
                        
                        
                        $arrayCont = [
                            'firstname'             => $currentUser->first_name,
                            'lastname'              => $currentUser->last_name,
                            'other_user_firstname'  => $user->first_name,
                            'other_user_lastname'   => $user->last_name,
                            'company_name'          => $currentCompany->name,
                            'group_name'            => '',
                            'content'               => '',
                            'code'                  => '',
                            'link'                  => $company_profile_url,
                        ];
                        
                        $email = new QueueEmail($this->adapter);
                        $email->processEmailTemplate($emailTemplate, $arrayCont, $user->email, trim($user->first_name . ' ' . $user->last_name));
                    }
                }
                
                
                $this->logger->info('La empresa : ' . $currentCompany->name . ' envio al usuario : ' . $user->email . ' una invitación ', ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                
                if($network->default == Network::DEFAULT_YES) {
                    return new JsonModel([
                        'success'   => true,
                        'data'      => 'LABEL_USER_COMPANY_HAS_BEEN_CREATED',
                    ]);
                } else {
                    return new JsonModel([
                        'success'   => true,
                        'data'      => 'LABEL_USER_COMPANY_HAS_BEEN_INVITED_SENT',
                    ]);
                }
                
                
            }  else {
                
                return new JsonModel([
                    'success'   => false,
                    'data'      => $userMapper->getError()
                ]);
            }
            
            
        }
        
        
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    
    
    public function deleteAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $currentCompany = $currentUserPlugin->getCompany();
        
        $request = $this->getRequest();
        
        
        if($request->isPost()) {
            
            $uuid = $this->params()->fromRoute('id');
            if(!$uuid) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_INVALID_PARAMETER'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($uuid);
            
            if(!$user) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_NOT_FOUND'
                    
                ]);
            }
            
            $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
            $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($currentCompany->id, $user->id);
            
            if($companyUser) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_COMPANY_NOT_FOUND'
                ]);
            }
            
            
            if(!$currentCompany->internal) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_INTERNAL_COMPANY_ONLY'
                ]);
            }

            

            $result = $companyUserMapper->delete($companyUser->id);
            if($result) {
                $this->logger->info('La relación del usuario : ' . $user->email . ' con la empresa : ' . $currentCompany->name  . ' ha sido eliminada ', ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                
                return new JsonModel([
                    'success'   => true,
                    'data'      => 'LABEL_USER_COMPANY_HAS_BEEN_DELETED',
                ]);
            }  else {
                
                return new JsonModel([
                    'success'   => false,
                    'data'      => $userMapper->getError()
                ]);
            }
            
            
        }
        
        
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    
    
    public function uploadAction()
    {
        $request = $this->getRequest();
        
        $currentNetworkPlugin = $this->plugin('currentNetworkPlugin');
        $currentNetwork    = $currentNetworkPlugin->getNetwork();
        
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser    = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();
        
        $request    = $this->getRequest();

        if($request->isPost()) {
            
            $step = Functions::sanitizeFilterString($this->params()->fromPost('step'));
            if($step == 'validation') {
                $userMapper = UserMapper::getInstance($this->adapter);
                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                
                $form = new  UserUploadForm();
                $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
                        
                      
                        $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']);
                        $isAdult = strtolower(Functions::sanitizeFilterString($record['E']));
                        $country = strtolower(Functions::sanitizeFilterString($record['F']));

                        
                        if(empty($first_name) || empty($last_name) || !filter_var($email, FILTER_VALIDATE_EMAIL) ||  empty($password)) {
                            continue;
                        }
                        
                        if(!in_array($email, $emails)) {
                            
                            $user = $userMapper->fetchOneByEmail($email);
                            
                            array_push($emails, $email);
                            array_push($users, [
                                'first_name' => $first_name,
                                'last_name' => $last_name,
                                'password'  => $password,
                                'email' => $email,
                                'is_adult' => $isAdult,
                                'country' => $country,

                            ]);
                        }
                        
                        
                        
                        
                        
                    }
                    
                    $key = md5($currentUser->id . '-' . microtime(true));
                    $this->cache->setItem($key, serialize($users));
                    
                    return new JsonModel([
                        'success' => true,
                        'data' => [
                            'key' => $key,
                            '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'
                    ]);
                }
                
                $locationMapper = LocationMapper::getInstance($this->adapter);
                $countryMapper = CountryMapper::getInstance($this->adapter);
                
                
                $networkMapper = NetworkMapper::getInstance($this->adapter);
                $networkDefault = $networkMapper->fetchOneByDefault();
                
                $userMapper = UserMapper::getInstance($this->adapter);
                $userPasswordMapper = UserPasswordMapper::getInstance($this->adapter);
                

                $user_ids_in_default_network = [];
                
                
                $users_created = 0;
                $user_ids = [];
                foreach($records as $record)
                {
                    $first_name = $record['first_name'];
                    $last_name = $record['last_name'];
                    $password = $record['password'];
                    $email = $record['email'];
                    
                    
                    $user = $userMapper->fetchOneByEmailAndNetworkId($email, $currentNetwork->id);
                    if(!$user) {
                        $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 = $record['is_adult'] == 'y' ? User::IS_ADULT_YES : User::IS_ADULT_NO;
                        
                        $result = $userMapper->insert($user);
                        if($result) {
                            $users_created++;
                            
                            $country_code = trim($record['country']);
                            
                            if($country_code) {
                                $country = $countryMapper->fetchOneByCodeOrCountry($record['country']);
                                if($country) {
                                
                                    $location = new Location();
                                    $location->formatted_address = $country->country;
                                    $location->country = $country->country;
                                    if($locationMapper->insert($location)) {
                                    
                                        $user->location_id = $location->id;
                                        $userMapper->updateLocation($user);
                                    }
                                    
                                }
                            } else {
                                $country_code = '';
                            }
                            
                            $userPassword = new UserPassword();
                            $userPassword->user_id = $user->id;
                            $userPassword->password = $password_hash;
                            $userPasswordMapper->insert($userPassword);
                            
                            
                            if($currentNetwork->default == Network::DEFAULT_YES) {
                                array_push($user_ids_in_default_network, $user->id);
                            } else {
                                
                                
                                
                                if($user->is_adult == User::IS_ADULT_YES) {
                                    
                                    $userInDefaultNetwork = $userMapper->fetchOneByEmailAndNetworkId($user->email, $networkDefault->id);
                                    if($userInDefaultNetwork) {
             
                                        array_push($user_ids_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)) {
                                                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 = User::IS_ADULT_YES;
                                        $result = $userMapper->insert($userInDefaultNetwork);
                                        if($result) {
                                            array_push($user_ids_in_default_network, $userInDefaultNetwork->id);
                                            
                                            if($country) {
                                                
                                                $location = new Location();
                                                $location->formatted_address = $country->country;
                                                $location->country = $country->country;
                                                if($locationMapper->insert($location)) {
                                                    
                                                    $userInDefaultNetwork->location_id = $location->id;
                                                    $userMapper->updateLocation($userInDefaultNetwork);
                                                }
                                                
                                            }
                                            
                                            
                                            $userPassword = new UserPassword();
                                            $userPassword->user_id = $userInDefaultNetwork->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;
                            }
                        }
                    }
                    
                    array_push($user_ids, $user->id);
                    
                }
                
                if($currentCompany) {
                
                    $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                    
                    $company_users_created = 0;
                    
                    foreach($user_ids as $user_id)
                    {
                        $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($currentCompany->id, $user_id);
                        if(!$companyUser) {
                            
                            $companyUser = new CompanyUser(); 
                            $companyUser->company_id = $currentCompany->id; 
                            $companyUser->user_id = $user_id; 
                            $companyUser->backend = CompanyUser::BACKEND_NO;
                            $companyUser->creator = CompanyUser::CREATOR_NO;
                            $companyUser->owner = CompanyUser::OWNER_NO; 
                            
                            if($currentNetwork->default == Network::DEFAULT_YES) {
                                $companyUser->status = CompanyUser::STATUS_ADMIN_WILL_ADD;
                            } else {
                                $companyUser->status = CompanyUser::STATUS_ACCEPTED;
                            }
                            
                            if($companyUserMapper->insert($companyUser)) {
                                $company_users_created++;
                            }
                            
                        }
                        
                    }
                    
                    $this->logger->info('Se agregaron ' . $users_created . '  usuarios  la empresa ' . $currentCompany->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                    
                    
                    
                } else {
                    
                    $this->logger->info('Se agregaron ' . $users_created . ' usuarios a la red', ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                    
                }
                
                if($user_ids_in_default_network) {
                    $companyMapper = CompanyMapper::getInstance($this->adapter);
                    $companyToFollower = $companyMapper->fetchOneDefaultForFollowers();
                    
                    $companyFollowerMapper = CompanyFollowerMapper::getInstance($this->adapter);
                    
                    $userToConnection = $userMapper->fetchOneDefaultForConnection();
                    
                    
                    $connectionMapper = ConnectionMapper::getInstance($this->adapter);
                    
                    foreach($user_ids_in_default_network as $user_id)
                    {
                        if($userToConnection) {
                            $connection = $connectionMapper->fetchOneByUserId1AndUserId2($user_id, $userToConnection->id);
                            if(!$connection) {
                                $connection = new Connection();
                                $connection->request_from = $user_id;
                                $connection->request_to = $userToConnection->id;
                                $connection->status = Connection::STATUS_ACCEPTED;
                                
                                $connectionMapper->insert($connection);
                            } else {
                                if($connection->status == Connection::STATUS_SENT) {
                                    $connectionMapper->approve($connection);
                                }
                            }
                        }
                        
                        if($companyToFollower) {
                            $companyFollower = $companyFollowerMapper->fetchOneByCompanyIdAndUserId($companyToFollower->id, $user_id);
                            if(!$companyFollower) {
                                $companyFollower = new CompanyFollower();
                                $companyFollower->company_id = $companyToFollower->id; 
                                $companyFollower->follower_id = $user_id;
                                
                                $companyFollowerMapper->insert($companyFollower);
                                
                            }
                        }
                        
                    }
                    
                    
                    
                    
                }
                
                
                
                return new JsonModel([
                    'success' => true,
                    'data' => [
                        'users_created' => $users_created
                    ]
                ]);
                
                
                
                
            } else {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_PARAMETERS_ARE_INVALID'
                ]);
            }
            
            
            
            
        }
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    
    
    public function editAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();
        
        $request = $this->getRequest();
        $uuid = $this->params()->fromRoute('id');
        
        
        if(!$uuid) {
            $data = [
                'success'   => false,
                'data'   => 'ERROR_INVALID_PARAMETER'
            ];
            
            return new JsonModel($data);
        }
        
        $userMapper = UserMapper::getInstance($this->adapter);
        $user = $userMapper->fetchOneByUuid($uuid);
        if(!$user) {
            $data = [
                'success'   => false,
                'data'   => 'ERROR_COMPANY_NOT_FOUND'
            ];
            
            return new JsonModel($data);
        }
        
        $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
        $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($currentCompany->id, $user->id);
        if(!$companyUser) {
            return new JsonModel([
                'success'   => false,
                'data'   => 'ERROR_COMPANY_USER_NOT_FOUND'
            ]);
   
        }
        
        if($companyUser->status != CompanyUser::STATUS_ACCEPTED && $companyUser->status != CompanyUser::STATUS_ADMIN_WILL_ADD) {
            return new JsonModel([
                'success'   => false,
                'data'   => 'ERROR_COMPANY_USER_IS_NOT_ACTIVE'
            ]);
        }
        
        
        
        
        if($request->isPost()) {
            
            $companyRoleMapper = CompanyRoleMapper::getInstance($this->adapter);
            $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
            $companyUserRoleMapper = CompanyUserRoleMapper::getInstance($this->adapter);
            
            $backend = Functions::sanitizeFilterString($this->params()->fromPost('backend') );
            $companyUser->backend = $backend == CompanyUser::BACKEND_YES ? CompanyUser::BACKEND_YES : CompanyUser::BACKEND_NO; 
            $companyUserMapper->update($companyUser);
            
            
            $roleMapper = RoleMapper::getInstance($this->adapter);
            $roles = $roleMapper->fetchAll();
            
            
            foreach($roles as $role)
            {
                $companyRole = $companyRoleMapper->fetchOneByCompanyIdAndRoleId($currentCompany->id, $role->id);
                if(!$companyRole) {
                    $companyUserRoleMapper->deleteByCompanyIdAndRoleId($currentCompany->id, $role->id); 
                    continue;
                } 
                
                $checked     = filter_var( $this->params()->fromPost('checked' . $role->id), FILTER_SANITIZE_NUMBER_INT);
                
        
                
                if($checked) {
                    
                    $companyUserRole = $companyUserRoleMapper->fetchOneByCompanyIdAndUserIdAndRoleId($currentCompany->id, $user->id, $role->id);
                    if(!$companyUserRole) {
                        
                        $companyUserRole = new CompanyUserRole(); 
                        $companyUserRole->company_id = $currentCompany->id;
                        $companyUserRole->role_id = $role->id;
                        $companyUserRole->user_id = $user->id;
                        
                        $companyUserRoleMapper->insert($companyUserRole);
                        
                    }
                    
                    
                    
                    
                } else {
      
                    $companyUserRoleMapper->deleteByCompanyIdAndUserIdAndRoleId($currentCompany->id, $user->id, $role->id);
                } 
            }
            
            $this->logger->info('Se actualizo los roles del usuario : ' . $user->email . ' en la empresa ' . $currentCompany->name, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
            
            return new JsonModel([
                'success' => true,
                'data' => 'LABEL_RECORD_UPDATED'
            ]);
            
            
        } else if ($request->isGet()) {
            $companyServiceMapper = CompanyServiceMapper::getInstance($this->adapter);
            
            $roleMapper = RoleMapper::getInstance($this->adapter);
            $records = $roleMapper->fetchAll();
            

             
            $companyRoleMapper = CompanyRoleMapper::getInstance($this->adapter);
            $companyUserRoleMapper = CompanyUserRoleMapper::getInstance($this->adapter);
            
            $roles = [];
            foreach($records as $record)
            {
                if($record->creator == Role::CREATOR_YES) {
                    continue;
                }
                
                if($record->service_id) {
                    $companyService = $companyServiceMapper->fetchOneByCompanyIdAndServiceId($currentCompany->id, $record->service_id);
                    if(!$companyService || $companyService->status == CompanyService::INACTIVE) {
                        continue;
                    }
                    
                }
                
               
                
                $companyRole = $companyRoleMapper->fetchOneByCompanyIdAndRoleId($currentCompany->id, $record->id);
                if(!$companyRole) {
                    continue;
                }
                
                $companyUserRole  = $companyUserRoleMapper->fetchOneByCompanyIdAndUserIdAndRoleId($currentCompany->id, $user->id, $record->id);
                
                
                $roles[ $record->id ] = [
                    'id' => $record->id,
                    'name' => $record->name,
                    'fixed' => $record->creator == Role::CREATOR_YES ? true : false,
                    'checked' => $companyUserRole ? true : false,
                ];
                
                
            }
            

            
            $data = [
                'success' => true,
                'data' => [
                   'backend' => $companyUser->backend == CompanyUser::BACKEND_YES ? 1 : 0,
                   'roles' => $roles,
                ] ,
            ];
            
            
            
            return new JsonModel($data);
        } else {
            $data = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
            
            return new JsonModel($data);
        }
        
        return new JsonModel($data);
    }
    
    
    public function changeTypeAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $request = $this->getRequest();
        
        if($request->isGet()) {
            $uuid = $this->params()->fromRoute('id');
            if(!$uuid) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_INVALID_PARAMETER'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($uuid);
            
            
            
            if($user) {
                return new JsonModel([
                    'success'   => true,
                    'data'      => [
                        'usertype_id' => $user->usertype_id,
                    ]
                ]);
            } else {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
        }
        
        if($request->isPost()) {
            
            $uuid = $this->params()->fromRoute('id');
            if(!$uuid) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_INVALID_PARAMETER'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($uuid);
            
            if(!$user) {
                return new JsonModel([
                    'success'   => false,
                    'data'      => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
            
            $dataPost = $request->getPost()->toArray();
            $form = new ChangeTypeForm();
            $form->setData($dataPost);
            
            if($form->isValid()) {
                $dataPost = (array) $form->getData();
                
                $result = $userMapper->updateUserTypeId($user, $dataPost['usertype_id']);
                if($result) {
                    $this->logger->info('Cambio del tipo de usuario realizado por realizado', ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                        
                        
                    return new JsonModel([
                        'success'   => true,
                        'data'      => 'LABEL_USER_CHANGE_TYPE_HAS_BEEN_UPDATED'
                            
                    ]);
                } else {
                    $this->logger->err('Cambio del tipo de usuario - error desconocido', ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                        
                    return new JsonModel([
                        'success'   => true,
                        'data'      => 'ERROR_THERE_WAS_AN_ERROR'
                            
                    ]);

                }
                
            } else {
                $messages = [];
                
                $form_messages = (array) $form->getMessages();
                foreach($form_messages  as $fieldname => $field_messages)
                {
                    $messages[$fieldname] = array_values($field_messages);
                }
                
                return new JsonModel([
                    'success'   => false,
                    'data'   => $messages
                ]);
            }
            
        }
        
        
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    
    
}