Proyectos de Subversion LeadersLinked - Backend

<?php
declare(strict_types=1);

namespace LeadersLinked\Controller;

use Laminas\Db\Adapter\AdapterInterface;

use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\Log\LoggerInterface;
use Laminas\View\Model\ViewModel;
use Laminas\View\Model\JsonModel;
use LeadersLinked\Mapper\QueryMapper;
use PhpOffice\PhpSpreadsheet\IOFactory;
use PhpOffice\PhpSpreadsheet\Spreadsheet;
use LeadersLinked\Form\DiscoveryContact\ContactDownloadForm;
use LeadersLinked\Mapper\DiscoveryContactMapper;
use Laminas\Mvc\I18n\Translator;
use LeadersLinked\Library\Functions;
use Laminas\Http\Response;
use LeadersLinked\Mapper\DiscoveryContactBlackListMapper;
use LeadersLinked\Mapper\UserMapper;
use Laminas\Db\Sql\Expression;
use LeadersLinked\Mapper\DiscoveryContactInteractionMapper;
use LeadersLinked\Mapper\DiscoveryContactInteractionTypeMapper;
use LeadersLinked\Model\DiscoveryContact;

class DiscoveryContactReportUserController 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();
        if($request->isGet()) {
            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();
            $currentCompany = $currentUserPlugin->getCompany();
            
            $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) {
                $user_uuid = $this->params()->fromQuery('user');
                if(!$user_uuid) {
                    
                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_PARAMETERS_ARE_INVALID'
                    ]);
                }
                
                $userMapper = UserMapper::getInstance($this->adapter);
                $user = $userMapper->fetchOneByUuid($user_uuid);
                
                if(!$user) {
                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_USER_NOT_FOUND'
                    ]);
                }
                
                
                $startDate = $this->params()->fromQuery('startDate');
                if (empty($startDate)) {
                    $startDate = date('Y-m-d');
                }
                
                $endDate = $this->params()->fromQuery('endDate');
                if (empty($endDate)) {
                    $endDate = date('Y-m-d');
                }
                
                $dtStartDate = \DateTime::createFromFormat('Y-n-d', $startDate);
                $dtEndDate = \DateTime::createFromFormat('Y-n-d', $endDate);
                
                
                
                if (!$dtStartDate || !$dtEndDate) {
                    $startDate = date('Y-m-d');
                    $endDate = date('Y-m-d');
                } else {
                    
                    if ($dtStartDate->getTimestamp() > $dtEndDate->getTimestamp()) {
                        $startDate = date('Y-m-d');
                        $endDate = date('Y-m-d');
                    }
                    
                }
                
                
                
                $discoveryContactInteractionTypeMapper = DiscoveryContactInteractionTypeMapper::getInstance($this->adapter);
                $discoveryContactInteractionType = $discoveryContactInteractionTypeMapper->fetchOneDefaultByCompanyId($currentCompany->id);
                if(!$discoveryContactInteractionType) {
                    $discoveryContactInteractionType = $discoveryContactInteractionTypeMapper->fetchOneFirstActiveByCompanyId($currentCompany->id);
                }
                
                
                
                
                
                $discoveryContactBlackListMapper = DiscoveryContactBlackListMapper::getInstance($this->adapter);
                $blacklist_ids = $discoveryContactBlackListMapper->fetchAllContactIdsByCompanyId($currentCompany->id);
                
                
                
                $queryMapper = QueryMapper::getInstance($this->adapter);
                $select = $queryMapper->getSql()->select();
                $select->from(['a' => DiscoveryContactMapper::_TABLE]);
                $select->join(['b' => DiscoveryContactInteractionMapper::_TABLE], 'a.id = b.contact_id', []);
                $select->columns([
                    'first_name',
                    'last_name',
                    'personal_email',
                    'corporate_email',
                    'company',
                    'position',
                    'country',
                    'state',
                    'city',
                    'phone',
                    'phone_extension',
                    'celular',
                    'whatsapp',
                    'linkedin',
                    'sector',
                    'scholarship',
                    'added_on'
                ]);
                
                if($blacklist_ids ) {
                    $select->where->notIn('a.id', $blacklist_ids );
                }
                $select->where->equalTo('b.interaction_type_id',  $discoveryContactInteractionType ? $discoveryContactInteractionType->id : 0);
                
                $select->where->equalTo('b.user_id', $user->id);
                $select->where->between(new Expression('DATE(a.added_on)'), $startDate, $endDate);
                
                
                
                $select->limit(100);
                $select->order('added_on ASC');
                
                

                
                $items = $queryMapper->fetchAll($select);
                
                return new JsonModel([
                    'success' => true, 
                    'data' => [
                        'items' => $items,
                    ]
                ]); 
                
                
            } else {
                $discoveryContactInteractionMapper = DiscoveryContactInteractionMapper::getInstance($this->adapter);
                $user_ids = $discoveryContactInteractionMapper->fetchAllUserIdsForCompanyId($currentCompany->id);
                
                $users = [];
                $userMapper = UserMapper::getInstance($this->adapter);
                $records = $userMapper->fetchAllByIds($user_ids);
                foreach($records as $record)
                {
                    $users[ $record->uuid ] = trim($record->first_name . ' ' . $record->last_name) . ' (' . $record->email . ')';
                }
                
                
                
                $form = new ContactDownloadForm();
                
                $this->layout()->setTemplate('layout/layout-backend.phtml');
                $viewModel = new ViewModel();
                $viewModel->setTemplate('leaders-linked/discovery-contact-report-by-user/index');
                $viewModel->setVariables([
                   'form' => $form,
                    'users' => $users
                ]);
                return $viewModel ;
            }
        }
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);;
    }
    
    public function downloadAction()
    {
        $request = $this->getRequest();
        if($request->isGet()) {
            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();
            $currentCompany = $currentUserPlugin->getCompany();
            
            $user_uuid = $this->params()->fromQuery('user');
            if(!$user_uuid) {
                
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_PARAMETERS_ARE_INVALID'
                ]);
            }
            
            $userMapper = UserMapper::getInstance($this->adapter);
            $user = $userMapper->fetchOneByUuid($user_uuid);
            
            if(!$user) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_USER_NOT_FOUND'
                ]);
            }
            
            
            $startDate = $this->params()->fromQuery('startDate');
            if (empty($startDate)) {
                $startDate = date('Y-m-d');
            }
            
            $endDate = $this->params()->fromQuery('endDate');
            if (empty($endDate)) {
                $endDate = date('Y-m-d');
            }
            
            $dtStartDate = \DateTime::createFromFormat('Y-n-d', $startDate);
            $dtEndDate = \DateTime::createFromFormat('Y-n-d', $endDate);
            
            
            
            if (!$dtStartDate || !$dtEndDate) {
                $startDate = date('Y-m-d');
                $endDate = date('Y-m-d');
            } else {
                
                if ($dtStartDate->getTimestamp() > $dtEndDate->getTimestamp()) {
                    $startDate = date('Y-m-d');
                    $endDate = date('Y-m-d');
                }
                
            }
            
            $discoveryContactInteractionTypeMapper = DiscoveryContactInteractionTypeMapper::getInstance($this->adapter);
            $discoveryContactInteractionType = $discoveryContactInteractionTypeMapper->fetchOneDefaultByCompanyId($currentCompany->id);
            if(!$discoveryContactInteractionType) {
                $discoveryContactInteractionType = $discoveryContactInteractionTypeMapper->fetchOneFirstActiveByCompanyId($currentCompany->id);
            }
            
            
            
            
          
            $discoveryContactBlackListMapper = DiscoveryContactBlackListMapper::getInstance($this->adapter);
            $blacklist_ids = $discoveryContactBlackListMapper->fetchAllContactIdsByCompanyId($currentCompany->id);
            
            
            
            $queryMapper = QueryMapper::getInstance($this->adapter);
            $select = $queryMapper->getSql()->select();
            $select->from(['a' => DiscoveryContactMapper::_TABLE]);
            $select->join(['b' => DiscoveryContactInteractionMapper::_TABLE], 'a.id = b.contact_id', []);
            $select->columns([
                'first_name',
                'last_name', 
                'personal_email', 
                'corporate_email', 
                'company', 
                'position',
                'country',
                'state', 
                'city', 
                'phone', 
                'phone_extension',
                'celular', 
                'whatsapp', 
                'linkedin', 
                'sector', 
                'scholarship',
                'added_on'
            ]);
            
            if($blacklist_ids ) {
                $select->where->notIn('a.id', $blacklist_ids );
            }
            $select->where->equalTo('b.interaction_type_id',  $discoveryContactInteractionType ? $discoveryContactInteractionType->id : 0);
                
            $select->where->equalTo('b.user_id', $user->id);
            $select->where->between(new Expression('DATE(a.added_on)'), $startDate, $endDate);
            
           

            $fileName = 'reporte_relevamiento_de_contactos_por_usuario.csv';
            $tempFilename = tempnam(sys_get_temp_dir(), 'reporte_relevamiento_de_contactos_por_usuario_' . time(). '.csv');
            
            $fp = fopen($tempFilename, 'w');
            fputcsv($fp, [
                $this->translator->translate('LABEL_FIRST_NAME'),
                $this->translator->translate('LABEL_LAST_NAME'),
                $this->translator->translate('LABEL_EMAIL'),
                $this->translator->translate('LABEL_START'),
                $this->translator->translate('LABEL_END'),
            ]);    
            

            
            fputcsv($fp, [
                $user->first_name,
                $user->last_name,
                $user->email,
                $startDate,
                $endDate,
            ]);    
            
            
            fputcsv($fp, [
                $this->translator->translate('LABEL_FIRST_NAME'),
                $this->translator->translate('LABEL_LAST_NAME'),
                $this->translator->translate('LABEL_PERSONAL_EMAIL'),
                $this->translator->translate('LABEL_CORPORATE_EMAIL'),
                $this->translator->translate('LABEL_COMPANY'),
                $this->translator->translate('LABEL_POSITION'),
                $this->translator->translate('LABEL_COUNTRY'),
                $this->translator->translate('LABEL_STATE'),
                $this->translator->translate('LABEL_CITY'),
                $this->translator->translate('LABEL_PHONE'),
                $this->translator->translate('LABEL_PHONE_EXTENSION'),
                $this->translator->translate('LABEL_CELULAR'),
                $this->translator->translate('LABEL_WHATSAPP'),
                $this->translator->translate('LABEL_LINKEDIN'),
                $this->translator->translate('LABEL_SECTOR'),
                $this->translator->translate('LABEL_SCHOLARSHIP'),
                $this->translator->translate('LABEL_ADDED_DATE')
            ]);
            
            
            $items = $queryMapper->fetchAll($select);
            
            foreach ( $items as $item )
            {
                fputcsv($fp,$item);
            }
            fclose($fp);
            
      
            
            
            $items = null;     
            
            $zipName = 'reporte_relevamiento_de_contactos_por_usuario.zip';
            $zipFilename = tempnam(sys_get_temp_dir(),  $zipName);
            
           
            
            
            $zip = new \ZipArchive;
            if ($zip->open($zipFilename,\ZipArchive::CREATE|\ZipArchive::OVERWRITE) === TRUE) {
                $zip->addFile($tempFilename, $fileName);
                $zip->close();
                
                
                $content = file_get_contents($zipFilename);
                
                @unlink($tempFilename);
                @unlink($zipFilename);
                
                
                return new JsonModel([
                    'success' => true,
                    'data' => [
                        'content' => base64_encode($content),
                        'basename' =>  $zipName
                        
                    ]
                ]);
                

                
                
            } else {
                
                @unlink($tempFilename);
                
                return new JsonModel([
                    'success' => true,
                    'data' => 'ERROR_ZIP_CREATE_FILE',
                ]);
            }
            

            
        }
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);;
    }
}