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\HabitUserMapper;
use LeadersLinked\Model\HabitUser;
use LeadersLinked\Mapper\UserMapper;

use LeadersLinked\Mapper\QueryMapper;
use Laminas\Paginator\Adapter\DbSelect;
use Laminas\Paginator\Paginator;
use LeadersLinked\Form\Habit\HabitUserForm;
use LeadersLinked\Form\Habit\HabitUserUploadForm;
use PhpOffice\PhpSpreadsheet\IOFactory;
use LeadersLinked\Mapper\LocationMapper;
use LeadersLinked\Mapper\CountryMapper;
use LeadersLinked\Mapper\NetworkMapper;
use LeadersLinked\Mapper\UserPasswordMapper;
use LeadersLinked\Model\User;
use LeadersLinked\Model\UserType;
use LeadersLinked\Model\Location;
use LeadersLinked\Model\UserPassword;
use LeadersLinked\Model\Network;
use LeadersLinked\Mapper\CompanyMapper;
use LeadersLinked\Mapper\CompanyFollowerMapper;
use LeadersLinked\Mapper\ConnectionMapper;
use LeadersLinked\Model\Connection;
use LeadersLinked\Model\CompanyFollower;

class HabitUserController 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() {
        $request = $this->getRequest();
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentCompany = $currentUserPlugin->getCompany();
        $currentUser = $currentUserPlugin->getUser();


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

           // $isJson = true;
            if ($isJson) {
    
                
                $search = $this->params()->fromQuery('search', []);
                $search = empty($search['value']) ? '' :  Functions::sanitizeFilterString($search['value']);

                $start = intval($this->params()->fromQuery('start', 0), 10);
                $records_x_page = intval($this->params()->fromQuery('length', 10), 10);
                $page =  intval($start / $records_x_page);
                $page++;
                
                $order = $this->params()->fromQuery('order', []);
                $order_field = empty($order[0]['column']) ? 99 : intval($order[0]['column'], 10);
                $order_direction = empty($order[0]['dir']) ? 'ASC' : Functions::sanitizeFilterString(filter_var($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';
                }
                
               

                $acl = $this->getEvent()->getViewModel()->getVariable('acl');
                $allowAdd = $acl->isAllowed($currentUser->usertype_id, 'habits/users/add');
               // $allowEdit = $acl->isAllowed($currentUser->usertype_id, 'habits/users/edit');
                $allowDelete = $acl->isAllowed($currentUser->usertype_id, 'habits/users/delete');
                //$allowUpload = $acl->isAllowed($currentUser->usertype_id, 'habits/users/upload');
      
              
                $items = [];
                
                $queryMapper = QueryMapper::getInstance($this->adapter);
                $select = $queryMapper->getSql()->select();
                $select->columns([]);
                $select->from(['cu' => HabitUserMapper::_TABLE]);
                $select->join(['u' => UserMapper::_TABLE], 'cu.user_id = u.id',  ['uuid', 'first_name', 'last_name', 'email']);
            
                
                $select->where->equalTo('cu.company_id', $currentCompany->id);
                
                if($search) {
                    $select->where->nest()->like('first_name', '%' . $search . '%')
                    ->or->like('last_name', '%' . $search . '%')
                    ->or->like('email', '%' . $search . '%')->unnest();
                }
                
                $select->order($order_field . ' ' . $order_direction);
                
                //echo $select->getSqlString($this->adapter->platform); exit;
                
                
                $paginatorAdapter = new DbSelect($select, $this->adapter);
                $paginator = new Paginator($paginatorAdapter);
                $paginator->setItemCountPerPage($records_x_page);
                $paginator->setCurrentPageNumber($page);
               
                $records = $paginator->getCurrentItems();
                
                foreach ($records as $record) 
                {
                    $item = [
                        'first_name' => $record['first_name'],
                        'last_name' => $record['last_name'],
                        'email' => $record['email'],
                        'actions' => [
                            //'link_edit' => $allowEdit ? $this->url()->fromRoute('habits/users/edit', ['id' => $record['uuid'] ]) : '',
                            'link_delete' => $allowDelete ? $this->url()->fromRoute('habits/users/delete', ['id' => $record['uuid'] ]) : '',
                        ]
                    ];

                    array_push($items, $item);
                }
                
               
                   

                return new JsonModel([
                    'success' => true,
                    'data' => [
                        'total' => $paginator->getTotalItemCount(),
                        'items' => $items,
                    ]
                ]);
            } else {
                
                
                $form = new HabitUserForm($this->adapter, $currentCompany->id);
                $formUploadUsers = new HabitUserUploadForm();

                $this->layout()->setTemplate('layout/layout-backend');
                $viewModel = new ViewModel();
                $viewModel->setTemplate('leaders-linked/habits/users.phtml');
                $viewModel->setVariables([
                    'form' =>  $form,
                    'formUploadUsers' => $formUploadUsers,
 
                ]);
                return $viewModel;
            }
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }

    }
    
    
   
    public function addAction() 
    { 
        $currentUserPlugin  = $this->plugin('currentUserPlugin');
        $currentCompany     = $currentUserPlugin->getCompany(); 
        $currentUser        = $currentUserPlugin->getUser();
        $request            = $this->getRequest();

        if($request->isPost()) {
            
            
            $dataPost = $request->getPost()->toArray();

            $form = new  HabitUserForm($this->adapter, $currentCompany->id);
            $form->setData($dataPost);
            
            if($form->isValid()) {
               
                $dataPost = (array) $form->getData();
                
                
                $userMapper = UserMapper::getInstance($this->adapter);
                $user = $userMapper->fetchOneByUuid($dataPost['user_id']);
                
                $habitUserMapper = HabitUserMapper::getInstance($this->adapter);
                $habitUser = $habitUserMapper->fetchOneByCompanyIdAndUserId($currentCompany->id, $user->id);
                
                if($habitUser) {
                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_HABITS_USER_NOT_FOUND'
                    ]);
                }
                
   
                
                
                $habitUser =  new HabitUser();
                $habitUser->network_id  = $currentCompany->network_id;
                $habitUser->company_id  = $currentCompany->id;
                $habitUser->user_id     = $user->id;
                $habitUser->access      = HabitUser::ACCESS_UNLIMITED;
                $habitUserMapper        = HabitUserMapper::getInstance($this->adapter);
                

                if($habitUserMapper->insert($habitUser)) {

                    
                    $this->logger->info('Se agrego el usuario ' . $user->first_name . ' ' . $user->last_name . ' (' . $user->email . ') ' , ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                    
                    $data = [
                        'success'   => true,
                        'data'   => 'LABEL_RECORD_ADDED'
                    ];
                } else {
                    $data = [
                        'success'   => false,
                        'data'      => $habitUserMapper->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 deleteAction() 
    {
        $request = $this->getRequest();
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentCompany = $currentUserPlugin->getCompany();
        $currentUser = $currentUserPlugin->getUser();

        $request = $this->getRequest();
        $uuid = $this->params()->fromRoute('id');
        $user_id = $this->params()->fromRoute('user_id');
        
        
        $userMapper = UserMapper::getInstance($this->adapter);
        $user = $userMapper->fetchOneByUuid($uuid);
        
        if(!$user) {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_USER_NOT_FOUND'
            ]);
            
        }
        
        $habitUserMapper = HabitUserMapper::getInstance($this->adapter);
        $habitUser = $habitUserMapper->fetchOneByCompanyIdAndUserId($currentCompany->id, $user->id);
        
        if(!$habitUser) {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_HABITS_USER_NOT_FOUND'
            ]);
        }
        
  
        
       

        if ($request->isPost()) {

            if ($habitUserMapper->delete($habitUser)) {
            $this->logger->info('Se borro el usuario ' . $user->first_name . ' ' . $user->last_name . ' (' . $user->email . ') ', ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);

                $data = [
                    'success' => true,
                    'data' => 'LABEL_RECORD_DELETED'
                ];
            } else {

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

                
            }
        } else {
            $data = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];


        }

        
        return new JsonModel($data);

    }
    
    
    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);
                $habitUserMapper = HabitUserMapper::getInstance($this->adapter);
                
                $form = new  HabitUserUploadForm();
                $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,
                        ]
                    ]);
                    
                    @unlink($final_filename);
                    
                    
                } 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) {
                    
                    $habitUserMapper = HabitUserMapper::getInstance($this->adapter);
                    
                    $company_users_created = 0;
                    
                    foreach($user_ids as $user_id)
                    {
                        $habitUser = $habitUserMapper->fetchOneByCompanyIdAndUserId($currentCompany->id, $user_id);
                        if(!$habitUser) {
                            
                            $habitUser = new HabitUser();
                            $habitUser->network_id  = $currentCompany->network_id;
                            $habitUser->company_id  = $currentCompany->id;
                            $habitUser->user_id     = $user_id;
                            $habitUser->access      = HabitUser::ACCESS_UNLIMITED;
    
                            
                            if($habitUserMapper->insert($habitUser)) {
                                $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'
        ]);
    }
    
   
}