Proyectos de Subversion LeadersLinked - Backend

<?php
/**
 * 
 * Controlador: Mis Perfiles 
 * 
 */
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 LeadersLinked\Mapper\UserMapper;

use LeadersLinked\Mapper\CompanyUserMapper;
use LeadersLinked\Mapper\ConversationMapper;
use LeadersLinked\Mapper\MessageMapper;
use LeadersLinked\Model\Conversation;
use LeadersLinked\Library\Image;
use Laminas\View\Model\JsonModel;
use LeadersLinked\Model\Message;
use LeadersLinked\Model\VideoConvert;
use LeadersLinked\Mapper\VideoConvertMapper;
use LeadersLinked\Form\Communication\CommunicationForm;
use LeadersLinked\Mapper\JobDescriptionMapper;
use LeadersLinked\Model\User;
use LeadersLinked\Model\Company;
use LeadersLinked\Mapper\OrganizationPositionMapper;



class CommunicationController 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()) {
            
            $jobDescriptionIdBoss = 0;
            $jobDescriptionMapper = JobDescriptionMapper::getInstance($this->adapter);
            $jobsDescription = $this->recursiveLoadJobDescription($currentUser, $currentCompany, $jobDescriptionMapper, $jobDescriptionIdBoss);
            
            
            
            $bossId = 0;
            $organizationPositionMapper = OrganizationPositionMapper::getInstance($this->adapter);
            $userMapper = UserMapper::getInstance($this->adapter);
            $jobDescriptionMapper = JobDescriptionMapper::getInstance($this->adapter);
            
            
            $positions = $this->recursiveLoadPosition($currentUser, $currentCompany, $organizationPositionMapper, $userMapper, $jobDescriptionMapper, $bossId);
            
            

            $form = new CommunicationForm();
            $this->layout()->setTemplate('layout/layout-backend');
            $viewModel = new ViewModel();
            $viewModel->setTemplate('leaders-linked/communication/index.phtml');
            $viewModel->setVariables([
                'form' => $form,
                'companyName' => $currentCompany->name,
                'jobsDescription' => $jobsDescription,
                'positions' => $positions
            ]);
            return $viewModel ;
            
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }

    /**
     *
     * @param User $currentUser
     * @param Company $currentCompany
     * @param JobDescriptionMapper $jobDescriptionMapper
     * @param int $jobDescriptionIdBoss
     * @return array
     */
    private function recursiveLoadJobDescription($currentUser, $currentCompany, $jobDescriptionMapper, $jobDescriptionIdBoss)
    {
        $items = [];
        $records = $jobDescriptionMapper->fetchAllByCompanyIdAndJobDescriptionIdBoss($currentCompany->id, $jobDescriptionIdBoss);
        
        
        foreach($records as $record)
        {
            
            
            
            array_push($items, [
                'uuid' => $record->uuid,
                'name' => $record->name,
                'children' => $this->recursiveLoadJobDescription($currentUser, $currentCompany, $jobDescriptionMapper, $record->id),
            ]);
        }
        
        return $items;
    }
    
    /**
     *
     * @param User $currentUser
     * @param Company $currentCompany
     * @param OrganizationPositionMapper $organizationPositionMapper
     * @param UserMapper $userMapper
     * @param JobDescriptionMapper $jobDescriptionMapper
     * @param int $bossId
     * @return array
     */
    private function recursiveLoadPosition($currentUser, $currentCompany, $organizationPositionMapper, $userMapper, $jobDescriptionMapper, $bossId)
    {
        $items = [];
        $records = $organizationPositionMapper->fetchAllByCompanyIdAndBossId($currentCompany->id, $bossId);
        
        
        foreach($records as $record)
        {
            
            $user = $userMapper->fetchOne($record->employee_id);
            $jobDescription = $jobDescriptionMapper->fetchOne($record->job_description_id);
            
            
            array_push($items, [
                'uuid' => $record->uuid,
                'name' => trim($user->first_name . ' ' . $user->last_name),
                'title' => $jobDescription->name,
                'children' => $this->recursiveLoadPosition($currentUser, $currentCompany, $organizationPositionMapper, $userMapper, $jobDescriptionMapper, $record->employee_id),
            ]);
        }
        
        return $items;
    }

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

            $data = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());
            
            $form = new CommunicationForm();
            $form->setData($data);
            
            if($form->isValid()) {
                $organizationPositionMapper = OrganizationPositionMapper::getInstance($this->adapter);
                $jobDescriptionMapper = JobDescriptionMapper::getInstance($this->adapter);
                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                $userMapper = UserMapper::getInstance($this->adapter);
                
                $dataPost = (array) $form->getData();
                

                
                $user_ids = [];
                $message_text = $dataPost['message'];
                
                $job_description_ids = $dataPost['job_description_id'];
                $position_ids = $dataPost['position_id'];
                
                
                $user_selected_ids = $dataPost['user_selected_id'];
                if(!empty($user_selected_ids)) {
                    
                    foreach($user_selected_ids as $uuid)
                    {
                        $user = $userMapper->fetchOneByUuid($uuid);
                        if(!in_array($user->id, $user_ids)) {
                            array_push($user_ids, $user->id);
                        }
                        
                        
                    }
                }
                
                if(!empty($job_description_ids)) {
                    foreach($job_description_ids as $uuid) 
                    {
                        $jobDescription = $jobDescriptionMapper->fetchOneByUuid($uuid);
                        if(!$jobDescription || $jobDescription->company_id != $currentCompany->id) {
                            continue;
                        }
                        
                        $records = $organizationPositionMapper->fetchAllByCompanyIdAndJobDescriptionId($jobDescription->company_id, $jobDescription->id);
                        if(!empty($records)) {
                            foreach($records as $record) {
                                if(!in_array($record->employee_id, $user_ids)) {
                                    array_push($user_ids, $record->employee_id);
                                }
                            }
                        }
                    }
                }
                
                if(!empty($position_ids)) {
                    foreach($position_ids as $uuid)
                    {
                        $organizationPosition = $organizationPositionMapper->fetchOneByUuid($uuid);
                        if(!$organizationPosition || $organizationPosition->company_id != $currentCompany->id) {
                            if(!in_array($organizationPosition->employee_id, $user_ids)) {
                                array_push($user_ids, $organizationPosition->employee_id);
                            }
                        }
                    } 
                }
                
                $owner = $companyUserMapper->fetchOwnerByCompanyId($currentCompany->id);   
                

                $records = $companyUserMapper->fetchAllActivesByCompanyIdAndUserIds($currentCompany->id, $user_ids);
                
                if(empty($records)) {
                    return new JsonModel([
                        'success'  => false,
                        'data' =>  'ERROR_MESSAGE_NOT_FOUND_TARGET_ACTIVES'
                    ]);
                }
             
                $message_tmp_filename   = '';
                $message_filename       = '';
                
                $type = Message::TYPE_TEXT;
                
                $files = $this->getRequest()->getFiles()->toArray();
                if(isset($files['file']) && empty($files['file']['error'])) {
                    $message_tmp_filename  = $files['file']['tmp_name'];
                    $message_filename      = $this->normalizeString($files['file']['name']);
                    
                    $mime_type = mime_content_type($message_tmp_filename);
                    
                    
                    if($mime_type == 'image/jpg' || $mime_type == 'image/jpeg' || $mime_type == 'image/png') {
                        $type = Message::TYPE_IMAGE;
                    } else if($mime_type == 'video/quicktime' || $mime_type == 'video/webm' || $mime_type == 'video/mpeg' || $mime_type == 'video/mpg' || $mime_type == 'video/mp4') {
                        $type = Message::TYPE_VIDEO;
                    } else if($mime_type == 'application/pdf') {
                        $type = Message::TYPE_DOCUMENT;
                    }
                }
                
                
                $message_sent = 0;
                $conversationMapper = ConversationMapper::getInstance($this->adapter);
                
                foreach($records as $record)
                {
                    
                    $conversation = $conversationMapper->fetchOneByUserId1AndUserId2($owner->user_id, $record->user_id);
      
                    
                    if($conversation) {
                        if($conversation->sender_id == $owner->id) {
                            $conversation->receiver_status = Conversation::STATUS_NORMAL;
                            $conversation->sender_status = $conversation->sender_status == Conversation::STATUS_DELETED ? Conversation::STATUS_DELETED : Conversation::STATUS_NORMAL;
                        } else {
                            $conversation->receiver_status = $conversation->receiver_status == Conversation::STATUS_DELETED ? Conversation::STATUS_DELETED : Conversation::STATUS_NORMAL;
                            $conversation->sender_status = Conversation::STATUS_NORMAL;
                        }
                      
                        if(!$conversationMapper->update($conversation)) {
                            return new JsonModel([
                                'success'  => false,
                                'data' => $conversationMapper->getError()
                            ]);
                        }
                    } else {
                        $conversation = new Conversation();
                        $conversation->sender_id = $owner->user_id;
                        $conversation->sender_status = Conversation::STATUS_DELETED;
       
                        $conversation->receiver_id = $record->user_id;
                        $conversation->receiver_status = Conversation::STATUS_NORMAL;

                        if(!$conversationMapper->insert($conversation)) {
                            continue;
                        }
                    }
                    
                    $message = new Message();
                    $message->conversation_id = $conversation->id;
                    $message->read = Message::NO;
                    $message->message = $message_text;
                    $message->receiver_id = $record->user_id;
                    $message->receiver_status = Message::STATUS_NORMAL;
                    $message->sender_id = $owner->user_id;
                    $message->sender_status = Message::STATUS_NORMAL;
                    $message->type = $type;

                    
                    $messageMapper = MessageMapper::getInstance($this->adapter);
                    if($messageMapper->insert($message)) {
                        $message_sent++;
                        $message = $messageMapper->fetchOne($message->id);
                        
        
                        
                        if( $type == Message::TYPE_DOCUMENT) {
                            try {
                                $target_path = $this->config['leaderslinked.fullpath.message'] . $message->uuid;
                                if(!file_exists($target_path)) {
                                    mkdir($target_path, 0755, true);
                                }
                                
                                $full_filename = $target_path  . DIRECTORY_SEPARATOR .$message_filename;
                                $result = @copy($message_tmp_filename, $full_filename);
                                if ($result) {
                                    
                                    $message->type = $type;
                                    $message->filename = basename($message_filename);
                                    $messageMapper->update($message);
                                } 
                            } catch(\Throwable $e) {
                                error_log($e->getTraceAsString());
                            }
                        }
                        if( $type == Message::TYPE_IMAGE) {
                            try {
                                $target_path = $this->config['leaderslinked.fullpath.message'] . $message->uuid;
                                if(!file_exists($target_path)) {
                                    mkdir($target_path, 0755, true);
                                }
                                
                                list($target_width, $target_height) = explode('x', $this->config['leaderslinked.image_sizes.message_image_size']);
                                
                                $message_filename = substr($message_filename, 0, strrpos($message_filename, '.'))  . '.png';
                                $crop_to_dimensions = false;
                                $unlink_source = false;
                                if(Image::uploadImage($message_tmp_filename, $target_path, $message_filename, $target_width, $target_height, $crop_to_dimensions, $unlink_source)) {
                                    $message->type = $type;
                                    $message->filename = basename($message_filename);
                                    $messageMapper->update($message);
                                }
                            } catch(\Throwable $e) {
                                error_log($e->getTraceAsString());
                            }
                        }
                        if( $type == Message::TYPE_VIDEO) {
                            try {
                                $target_path = $this->config['leaderslinked.fullpath.message'] . $message->uuid;
                                if(!file_exists($target_path)) {
                                    mkdir($target_path, 0755, true);
                                }
                                
                                $full_filename = $target_path  . DIRECTORY_SEPARATOR . $message_filename;
                                $result = @copy($message_tmp_filename, $full_filename);
                                if ($result) {
                                    
                                    $size = $this->config['leaderslinked.image_sizes.message_image_size'];
                                    $getFromSecound = 2;
                                    
                                    //extracción del cover
                                    $generateFileName = substr($message_filename, 0, strrpos($message_filename, '.'));
                                    $generateFile =  $target_path  . DIRECTORY_SEPARATOR . $generateFileName .  '.png';
                                    $cmd            = "/usr/bin/ffmpeg -i $full_filename -an -ss $getFromSecound -s $size $generateFile";
                                    exec($cmd);
                                    
                                    
                                    $message->type = $type;
                                    $message->filename = basename($message_filename);
                                    $message->image_preview = basename($generateFile);
                                    $messageMapper->update($message);
                                    
                                    $videoConvert = new VideoConvert();
                                    $videoConvert->filename = $full_filename;
                                    $videoConvert->type = VideoConvert::TYPE_FEED;
                                    
                                    $videoConvertMapper = VideoConvertMapper::getInstance($this->adapter);
                                    $videoConvertMapper->insert($videoConvert);
                                }
                            } catch(\Throwable $e) {
                                error_log($e->getTraceAsString());
                            }
                        } 
                    } else {
                        return new JsonModel([
                            'success'   => false,
                            'data'   => $messageMapper->getError()
                        ]);
                    }
                }
                
                if(1 == $message_sent) {
                    return new JsonModel([
                        'success'   => true,
                        'data'   => 'LABEL_MESSAGE_ONE_SENT'
                    ]);
                } else {
                    $message = strval($message_sent) . 'LABEL_MESSAGE_TWO_OR_MORE_SENT';
                    return new JsonModel([
                        'success'   => true,
                        'data'   => $message
                    ]);
                }
                
                
            } 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 {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }

    }

    private function normalizeString ($str = '')
    {
        $basename  = substr($str, 0, strrpos($str, '.'));
        $basename  = str_replace('.', '-', $basename);
        
        $extension  = substr($str, strrpos($str, '.'));
        
        $str = $basename . $extension;
        
        $str = strip_tags($str);
        $str = preg_replace('/[\r\n\t ]+/', ' ', $str);
        $str = preg_replace('/[\"\*\/\:\<\>\?\'\|\,]+/', ' ', $str);
        $str = strtolower($str);
        $str = html_entity_decode( $str, ENT_QUOTES, "utf-8" );
        $str = htmlentities($str, ENT_QUOTES, "utf-8");
        $str = preg_replace("/(&)([a-z])([a-z]+;)/i", '$2', $str);
        $str = str_replace(' ', '-', $str);
        $str = rawurlencode($str);
        $str = str_replace('%', '-', $str);
        return trim(strtolower($str));
    }
    
}