Proyectos de Subversion LeadersLinked - Antes de SPA

<?php
declare(strict_types=1);

namespace LeadersLinked\Controller;

use Laminas\Authentication\AuthenticationService;
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\QueryMapper;
use LeadersLinked\Mapper\UserMapper;
use LeadersLinked\Model\UserExperience;
use LeadersLinked\Mapper\UserExperienceMapper;
use Laminas\Db\Sql\Select;
use LeadersLinked\Mapper\CompanyMapper;
use LeadersLinked\Model\User;
use LeadersLinked\Mapper\LocationMapper;
use LeadersLinked\Mapper\CompanySizeMapper;
use LeadersLinked\Mapper\GroupMapper;
use LeadersLinked\Mapper\GroupMemberMapper;
use LeadersLinked\Mapper\IndustryMapper;
use Laminas\Paginator\Adapter\DbSelect;
use Laminas\Paginator\Paginator;
use LeadersLinked\Mapper\UserSkillMapper;
use LeadersLinked\Mapper\SkillMapper;
use LeadersLinked\Model\Job;
use LeadersLinked\Mapper\ConnectionMapper;
use LeadersLinked\Mapper\UserProfileMapper;
use LeadersLinked\Model\UserProfile;
use Laminas\Db\Sql\Expression;
use LeadersLinked\Mapper\GroupTypeMapper;
use LeadersLinked\Mapper\JobMapper;
use LeadersLinked\Mapper\ProfileVisitMapper;
use LeadersLinked\Mapper\CompanyLocationMapper;
use LeadersLinked\Mapper\CompanyFollowerMapper;
use LeadersLinked\Mapper\JobApplicationMapper;
use LeadersLinked\Model\UserType;
use LeadersLinked\Mapper\UserBlockedMapper;
use LeadersLinked\Mapper\CompanyUserMapper;
use LeadersLinked\Model\CompanyUser;
use LeadersLinked\Model\Company;
use LeadersLinked\Model\Group;
use LeadersLinked\Mapper\NetworkMapper;
use LeadersLinked\Model\Network;

class ImpersonateController 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()
    {
        $page       = (int) filter_var($this->params()->fromQuery('page'), FILTER_SANITIZE_NUMBER_INT);
        $keyword    = Functions::sanitizeFilterString($this->params()->fromQuery('keyword'));
      
        
        $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) {
                $currentUserPlugin = $this->plugin('currentUserPlugin');
                $currentUser = $currentUserPlugin->getUser();
                
                $networkMapper = NetworkMapper::getInstance($this->adapter);
                $records = $networkMapper->fetchAllActives();
                
                $networks = [];
                foreach($records as $record)
                {
                    $networks[$record->id] = $record->name;
                }
          

                
                $queryMapper = QueryMapper::getInstance($this->adapter);
                $select = $queryMapper->getSql()->select();
                $select->columns(['id', 'uuid', 'network_id', 'user_uuid' => 'uuid', 'first_name','last_name', 'email','image']);
                $select->from(['u' => UserMapper::_TABLE]);
                $select->where->equalTo('u.status', User::STATUS_ACTIVE);
                $select->where->equalTo('u.email_verified', User::EMAIL_VERIFIED_YES);
                $select->where->in('u.usertype_id', [UserType::USER, UserType::ADMIN]);
                $select->where->equalTo('u.status', User::STATUS_ACTIVE);
                $select->where->notEqualTo('u.is_super_user', User::IS_SUPER_USER_YES);
                        
                if($keyword) {
                    $select->where->NEST->like('u.email', '%' . $keyword . '%')->or->like('u.first_name', '%' . $keyword . '%')->or->like('u.last_name', '%' . $keyword . '%')->UNNEST;
                }
                
                $dbSelect = new DbSelect($select, $this->adapter);
                $paginator = new Paginator($dbSelect);
                $paginator->setCurrentPageNumber($page ? $page : 1);
                $paginator->setItemCountPerPage(10);
                
                
                
               
                
                $items = [];
                $records = $paginator->getCurrentItems();
                foreach($records as $record)
                {
                    $item = [
                        'id' => $record['uuid'],
                        'name' => $record['first_name'] . ' ' . $record['last_name'], 
                        'email' => $record['email'],
                        'network' => $networks[$record['network_id']],
                        'image' => $this->url()->fromRoute('storage',['type' => 'user', 'code' =>  $record['user_uuid'], 'filename' => $record['image']]),
                        'link_impersonate' => $this->url()->fromRoute('impersonate/execute',['id' => $record['user_uuid'] ]),
                        
                        
                    ]; 
                    array_push($items, $item);                                

                }
                
                $response = [
                    'success' => true,
                    'data' => [
                        'total' => [
                            'count' => $paginator->getTotalItemCount(),
                            'pages' => $paginator->getPages()->pageCount,
                        ],
                        'current' => [
                            'items'    => $items,
                            'page'     => $paginator->getCurrentPageNumber(),
                            'count'    => $paginator->getCurrentItemCount(),
                        ]
                    ]
                ];
                
                
                
                return new JsonModel($response);
            } else {
             

                $viewModel = new ViewModel();
                $this->layout()->setTemplate('layout/layout.phtml');
                $viewModel->setTemplate('leaders-linked/impersonate/index.phtml');
                
                return $viewModel;
            }
        }
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
        
        
       
        
    }
    
    public function executeAction() 
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $id = $this->params()->fromRoute('id');
        if(!$id) {
            return new JsonModel([
                'success' => false,
                'data' =>  'ERROR_PARAMETERS_ARE_INVALID'
            ]);
        }
        
        
        $request = $this->getRequest();
        if($request->isGet()) {
        
            $userMapper = UserMapper::getInstance($this->adapter);
            $userImpersonate = $userMapper->fetchOneByUuid($id);
            
            if(!$userImpersonate) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_USER_NOT_FOUND'
                ]);
                
               
            }
            
            if($currentUser->id == $userImpersonate->id) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_CANNOT_IMPERSONATE_ITSELF',
                ]);
            }
            
            if($userImpersonate->is_super_user == User::IS_SUPER_USER_YES) {
                return new JsonModel([
                    'success' => false,
                    'data' =>  'ERROR_CANNOT_IMPERSONATE_A_SUPER_ADMIN',
                ]);
            }
            
            if($userImpersonate->status != User::STATUS_ACTIVE || $userImpersonate->email_verified != User::EMAIL_VERIFIED_YES) {
                return new JsonModel([
                    'success' => false,
                    'data' =>  'ERROR_CANNOT_IMPERSONATE_AN_INACTIVE_OR_UNVERIFIED_USER',
                ]);
            }
            
            $userMapper->startImpersonate($currentUser->id, $userImpersonate->id);
            
            $networkMapper = NetworkMapper::getInstance($this->adapter);
            $network = $networkMapper->fetchOne($userImpersonate->network_id);
            
            
            if(!$currentUser->one_time_password) {
                $one_time_password = Functions::generatePassword(25);
                
                $currentUser->one_time_password = $one_time_password;
                
                $userMapper = UserMapper::getInstance($this->adapter);
                $userMapper->updateOneTimePassword($currentUser, $one_time_password);
            }
            
            
            $sandbox = $this->config['leaderslinked.runmode.sandbox'];
            if($sandbox) {
                $salt = $this->config['leaderslinked.backend.sandbox_salt'];
            } else {
                $salt = $this->config['leaderslinked.backend.production_salt'];
            }
            
            
            
            
            $rand = 1000 + mt_rand(1, 999);
            $timestamp = time();
            $password = md5($currentUser->one_time_password . '-' . $rand . '-' . $timestamp . '-' . $salt);
            
            $params = [
                'user_uuid' => $currentUser->uuid,
                'password' => $password,
                'rand' => $rand,
                'time' => $timestamp,
            ];
          
            
            $currentUserPlugin->clearIdentity();
            $url = 'https://'. $network->main_hostname . '/signin/impersonate' . '?' . http_build_query($params);
            
            return new JsonModel([
                'success' => true,
                'data' => $url,
              
            ]);
            
          
        }
            
    
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    
    }
    
    
}