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 Laminas\View\Model\JsonModel;

use LeadersLinked\Mapper\CompanyMapper;
use LeadersLinked\Mapper\CompanyUserMapper;
use LeadersLinked\Form\CreateFeedForm;
use LeadersLinked\Form\CommentForm;
use LeadersLinked\Form\CommentAnswerForm;
use LeadersLinked\Model\Comment;
use LeadersLinked\Mapper\CommentMapper;
use LeadersLinked\Mapper\FeedMapper;
use LeadersLinked\Mapper\GroupMapper;
use LeadersLinked\Model\Feed;
use LeadersLinked\Mapper\QueryMapper;
use LeadersLinked\Hydrator\ObjectPropertyHydrator;
use LeadersLinked\Library\Image;
use LeadersLinked\Model\VideoConvert;
use LeadersLinked\Mapper\VideoConvertMapper;
use LeadersLinked\Mapper\LikeMapper;
use Laminas\Paginator\Adapter\DbSelect;
use Laminas\Paginator\Paginator;
use LeadersLinked\Mapper\UserMapper;
use LeadersLinked\Library\Functions;
use LeadersLinked\Model\Company;

use LeadersLinked\Mapper\TopicMapper;
use LeadersLinked\Model\HighPerformanceTeamsGroupsMembers;
use LeadersLinked\Model\HighPerformanceTeamsGroups;
use LeadersLinked\Mapper\HighPerformanceTeamsGroupsMembersMapper;
use LeadersLinked\Mapper\HighPerformanceTeamsGroupsMapper;
use LeadersLinked\Mapper\FastSurveyMapper;
use LeadersLinked\Model\FastSurvey;
use LeadersLinked\Form\FastSurvey\FastSurveyForm;

class FeedController 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;
    }

    /**
     * 
     * Generación del listado de perfiles
     * {@inheritDoc}
     * @see \Laminas\Mvc\Controller\AbstractActionController::indexAction()
     */
    public function indexAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();



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

            $formFeed = new CreateFeedForm($this->adapter);

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


    public function commentAction()
    {


        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();


        $id = $this->params()->fromRoute('id');

        $request = $this->getRequest();
        if ($request->isPost()) {
            $feedMapper = FeedMapper::getInstance($this->adapter);
            $feed = $feedMapper->fetchOneByUuidAndNetworkId($id, $currentUser->network_id);
            if (!$feed) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }

            if ($feed->company_id != $currentCompany->id) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_UNAUTHORIZED'
                ];
                return new JsonModel($response);
            }

            $dataPost = $request->getPost()->toArray();
            $form = new CommentForm();
            $form->setData($dataPost);

            if ($form->isValid()) {
                $now = $feedMapper->getDatebaseNow();

                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                $owner = $companyUserMapper->fetchOwnerByCompanyId($currentCompany->id);

                $dataPost = (array) $form->getData();
                $comment = new Comment();
                $comment->comment = $dataPost['comment'];
                $comment->feed_id = $feed->id;
                $comment->network_id = $currentUser->network_id;

                if ($feed->type == 'hptg') {
                    $comment->user_id = $currentUser->id;
                } else if ($feed->type == 'mytq') {
                    $comment->user_id = $currentCompany->id;
                } else {
                    $comment->user_id = $owner->user_id;
                }

                $commentMapper = CommentMapper::getInstance($this->adapter);
                if ($commentMapper->insert($comment)) {

                    $total_comments = $commentMapper->fetchCountCommentByFeedId($comment->feed_id);

                    $feed->total_comments = $total_comments;
                    $feedMapper->update($feed);

                    $response = [
                        'success'   => true,
                        'data'   => $this->renderComment($comment->id, $now),
                        'total_comments' => $total_comments
                    ];

                    return new JsonModel($response);
                } else {

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

                    return new JsonModel($response);
                }
            } else {
                $message = '';;
                $form_messages = (array) $form->getMessages();
                foreach ($form_messages  as $fieldname => $field_messages) {
                    foreach ($field_messages as $key => $value) {
                        $message = $value;
                    }
                }

                $response = [
                    'success'   => false,
                    'data'   => $message
                ];

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

            return new JsonModel($response);
        }
    }

    public function answerAction()
    {


        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();


        $id = $this->params()->fromRoute('id');
        $comment_uuid = $this->params()->fromRoute('comment');

        $request = $this->getRequest();
        if ($request->isPost()) {
            $feedMapper = FeedMapper::getInstance($this->adapter);
            $feed = $feedMapper->fetchOneByUuid($id);
            if (!$feed) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }

            if ($feed->company_id != $currentCompany->id) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_UNAUTHORIZED'
                ];
                return new JsonModel($response);
            }

            $dataPost = $request->getPost()->toArray();
            $form = new CommentAnswerForm();
            $form->setData($dataPost);

            if ($form->isValid()) {
                $now = $feedMapper->getDatebaseNow();

                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                $owner = $companyUserMapper->fetchOwnerByCompanyId($currentCompany->id);

                $dataPost = (array) $form->getData();
                $answer = new Comment();
                $answer->comment = $dataPost['answer'];
                $answer->feed_id = $feed->id;

                if ($feed->type == 'hptg') {
                    $answer->user_id = $currentUser->id;
                } else {
                    $answer->user_id = $owner->user_id;
                }

                $commentMapper = CommentMapper::getInstance($this->adapter);
                $comment = $commentMapper->fetchOneByUuid($comment_uuid);
                $answer->parent_id = $comment->id;

                if ($commentMapper->insert($answer)) {

                    $total_comments = $commentMapper->fetchCountCommentByFeedId($comment->feed_id);

                    $feed->total_comments = $total_comments;
                    $feedMapper->update($feed);

                    $response = [
                        'success'   => true,
                        'data'   => $this->renderComment($answer->id, $now),
                        'total_comments' => $total_comments
                    ];

                    return new JsonModel($response);
                } else {

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

                    return new JsonModel($response);
                }
            } else {
                $message = '';;
                $form_messages = (array) $form->getMessages();
                foreach ($form_messages  as $fieldname => $field_messages) {
                    foreach ($field_messages as $key => $value) {
                        $message = $value;
                    }
                }

                $response = [
                    'success'   => false,
                    'data'   => $message
                ];

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

            return new JsonModel($response);
        }
    }



    public function commentDeleteAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();

        $request = $this->getRequest();
        if ($request->isPost()) {
            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();

            $id = $this->params()->fromRoute('id');
            $comment = $this->params()->fromRoute('comment');

            $feedMapper = FeedMapper::getInstance($this->adapter);
            $feed = $feedMapper->fetchOneByUuidAndNetworkId($id, $currentUser->network_id);
            if (!$feed) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }

            if ($feed->company_id != $currentCompany->id) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_UNAUTHORIZED'
                ];
                return new JsonModel($response);
            }

            $commentMapper = CommentMapper::getInstance($this->adapter);
            $comment = $commentMapper->fetchOneByUuid($comment);

            if ($comment && $comment->feed_id == $feed->id) {
                $comment->status = Comment::STATUS_DELETED;
                if ($commentMapper->update($comment)) {
                    $total_comments = $commentMapper->fetchCountCommentByFeedId($comment->feed_id);

                    $feed = $feedMapper->fetchOne($comment->feed_id);
                    $feed->total_comments = $total_comments;
                    $feedMapper->update($feed);





                    $response = [
                        'success' => true,
                        'data' => [
                            'message' => 'LABEL_COMMENT_WAS_DELETED',
                            'total_comments' => $total_comments
                        ]
                    ];
                } else {
                    $response = [
                        'success' => false,
                        'data' => $commentMapper->getError()
                    ];
                }
            } else {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_COMMENT_NOT_FOUND'
                ];
            }
        } else {
            $response = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
        }

        return new JsonModel($response);
    }

    public function deleteAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();

        $request = $this->getRequest();
        if ($request->isPost()) {


            $id =  $this->params()->fromRoute('id');

            $feedMapper = FeedMapper::getInstance($this->adapter);
            $feed = $feedMapper->fetchOneByUuidAndNetworkId($id, $currentUser->network_id);
            if (!$feed) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }

            if ($feed->company_id != $currentCompany->id) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_UNAUTHORIZED'
                ];
                return new JsonModel($response);
            }

            $feedMapper = FeedMapper::getInstance($this->adapter);
            $feed->status = Feed::STATUS_DELETED;
            if ($feedMapper->update($feed)) {
                $response = [
                    'success' => true,
                    'data' => 'LABEL_FEED_WAS_DELETED'
                ];
            } else {
                $response = [
                    'success' => false,
                    'data' => $feedMapper->getError()
                ];
            }


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

        return new JsonModel($response);
    }

    public function addAction()
    {
        

        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $currentNetworkPlugin = $this->plugin('currentNetworkPlugin');
        $currentNetwork = $currentNetworkPlugin->getNetwork();
        
        
        $currentCompany = $currentUserPlugin->getCompany();
        $myt_id =  $this->params()->fromRoute('myt_id');
        $hptg_uuid =  $this->params()->fromRoute('hptg_id');

        $request = $this->getRequest();
        if ($request->isPost()) {


            $dataPost = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());
            $feed_content_type = empty($dataPost['feed_content_type']) ? '' :  $dataPost['feed_content_type'];
            
            
            if( $feed_content_type == Feed::FILE_TYPE_FAST_SURVEY) {
                
                $form = new FastSurveyForm();
                $form->setData($dataPost);
                
                if ($form->isValid()) {
                    
                    $dataPost = (array) $form->getData();
                    
                    $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                    $companyUser = $companyUserMapper->fetchOwnerByCompanyId($currentCompany->id);
                    $now = $companyUserMapper->getDatebaseNow();
                    
                    
                    $hydrator = new ObjectPropertyHydrator();
                    $fastSurvey = new FastSurvey();
                    $hydrator->hydrate($dataPost, $fastSurvey);
                    
                    $fastSurvey->network_id = $currentNetwork->id;
                    $fastSurvey->company_id = $currentCompany->id;
                    $fastSurvey->user_id = $companyUser->id;
                    $fastSurvey->status = FastSurvey::STATUS_ACTIVE;
                    
                    $fastSurveyMapper = FastSurveyMapper::getInstance($this->adapter);
                    $result = $fastSurveyMapper->insert($fastSurvey);
                    if ($result) {
                        $feed = new Feed();
                        $feed->company_id = $currentCompany->id;
                        $feed->network_id = $currentNetwork->id;
                        $feed->user_id = $companyUser->id;
                        $feed->fast_survey_id = $fastSurvey->id;
                        $feed->type = Feed::TYPE_COMPANY;
                        $feed->file_type = Feed::FILE_TYPE_FAST_SURVEY;
                        $feed->posted_or_shared = Feed::POSTED;
                        $feed->status = Feed::STATUS_PUBLISHED;
                        $feed->title = '';
                        $feed->description = '';
                        $feed->total_comments   = 0;
                        $feed->total_shared     = 0;
                        $feed->shared_with      = Feed::SHARE_WITH_CONNECTIONS;
                        
                        $feedMapper = FeedMapper::getInstance($this->adapter);
                        $feedMapper->insert($feed);
                        
                        $this->logger->info('Se agrego la encuesta rápida : ' . $fastSurvey->question, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                        
                        $response = [
                            'success'   => true,
                            'data'   => $this->renderFeed($feed->id, $now)
                        ];
                        
                        
                    } else {
                        $response = [
                            'success' => false,
                            'data' => $fastSurveyMapper->getError()
                        ];
                    }
                    
                    return new JsonModel($response);
                } 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 {
           
            
            
                
                $form = new CreateFeedForm($this->adapter);
    
                $form->setData($dataPost);
    
                if ($form->isValid()) {
    
    
                    $companyMapper = CompanyMapper::getInstance($this->adapter);
                    $now = $companyMapper->getDatebaseNow();
                    
                    
                    $company = $companyMapper->fetchOne($currentCompany->id);
    
                    $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                    $owner = $companyUserMapper->fetchOwnerByCompanyId($company->id);
    
                    $dataPost['priority'] =  isset($dataPost['priority']) ? Feed::PRIORITY_URGENT  : '';
    
    
                    $hydrator = new ObjectPropertyHydrator();
                    $feed = new Feed();
                    $hydrator->hydrate($dataPost, $feed);
                    if ($hptg_uuid) {
    
    
    
                        $highPerformanceTeamsGroupsMapper = HighPerformanceTeamsGroupsMapper::getInstance($this->adapter);
                        $highPerformanceTeamsGroups = $highPerformanceTeamsGroupsMapper->fetchOneByUuid($hptg_uuid);
    
                        if (!$highPerformanceTeamsGroups) {
                            $data = [
                                'success' => false,
                                'data' => 'ERROR_RECORD_NOT_FOUND'
                            ];
    
                            return new JsonModel($data);
                        }
    
                        if ($highPerformanceTeamsGroups->status != HighPerformanceTeamsGroups::STATUS_ACTIVE) {
    
                            return new JsonModel([
                                'success' => false,
                                'data' => 'ERROR_UNAUTHORIZED'
                            ]);
                        }
    
                        $highPerformanceTeamsGroupsMemberMapper = HighPerformanceTeamsGroupsMembersMapper::getInstance($this->adapter);
                        $highPerformanceTeamsGroupsMember = $highPerformanceTeamsGroupsMemberMapper->fetchOneByGroupIdAndUserId($highPerformanceTeamsGroups->id, $currentUser->id);
                        if ($highPerformanceTeamsGroupsMember) {
                            if ($highPerformanceTeamsGroupsMember->status == HighPerformanceTeamsGroupsMembers::STATUS_ACCEPTED || $highPerformanceTeamsGroupsMember->status == HighPerformanceTeamsGroupsMembers::STATUS_ADDED_BY_ADMIN) {
                                $id =  $highPerformanceTeamsGroups->id;
                            } else {
    
                                return new JsonModel([
                                    'success' => false,
                                    'data' => 'ERROR_UNAUTHORIZED'
                                ]);
                            }
                        } else {
    
                            return new JsonModel([
                                'success' => false,
                                'data' => 'ERROR_RECORD_NOT_FOUND'
                            ]);
                        }
                        $topic_uuid =  $this->params()->fromRoute('topic_id');
                        if ($topic_uuid) {
                            $topicMapper = TopicMapper::getInstance($this->adapter);
                            $topic = $topicMapper->fetchOneByUuid($topic_uuid);
                            if ($topic) {
                                $feed->topic_id = $topic->id;
                            } else {
                                return new JsonModel([
                                    'success' => false,
                                    'data' => 'ERROR_RECORD_NOT_FOUND'
                                ]);
                            }
                        }
    
    
                        $feed->network_id       = $currentUser->network_id;
                        $feed->company_id       = $currentCompany->id;
                        $feed->group_id         = null;
                        $feed->high_performance_group_id = $id;
                        $feed->user_id          = $currentUser->id;
                        $feed->type             = Feed::TYPE_HPTG;
                        $feed->posted_or_shared = Feed::POSTED;
                        $feed->shared_with      = Feed::SHARE_WITH_CONNECTIONS;
                    } else if ($myt_id) {
                        $feedMapper = FeedMapper::getInstance($this->adapter);
                        $myt  = $feedMapper->fetchOneByUuid($myt_id);
                        $feed->network_id       = $currentUser->network_id;
                        $feed->company_id       = $currentCompany->id;
                        $feed->group_id         = null;
                        $feed->user_id          = $owner->user_id;
                        $feed->myt_id           = $myt->id;
                        $feed->related_feed     = $myt->id;
                        $feed->type             = Feed::TYPE_MYT_ANSWER;
                        $feed->posted_or_shared = Feed::POSTED;
                        $feed->shared_with      = Feed::SHARE_WITH_PUBLIC;
                    } else {
                        $feed->network_id       = $currentUser->network_id;
                        $feed->company_id       = $currentCompany->id;
                        $feed->group_id         = null;
                        $feed->user_id          = $owner->user_id;
                        $feed->type             = Feed::TYPE_COMPANY;
                        $feed->posted_or_shared = Feed::POSTED;
                        $feed->shared_with      = Feed::SHARE_WITH_CONNECTIONS;
                    }
    
    
    
    
                    $feed->total_comments   = 0;
                    $feed->total_shared     = 0;
    
    
                    $files = $this->getRequest()->getFiles()->toArray();
                    $file_type = '';
                    if (isset($files['file']) && empty($files['file']['error'])) {
                        $feed_tmp_filename  = $files['file']['tmp_name'];
                        $feed_filename      = $this->normalizeString($files['file']['name']);
    
                        $mime_type = mime_content_type($feed_tmp_filename);
                        if ($mime_type == 'image/jpg' || $mime_type == 'image/jpeg' || $mime_type == 'image/png') {
                            $file_type = Feed::FILE_TYPE_IMAGE;
                        } else if ($mime_type == 'video/webm' || $mime_type == 'video/mpeg' || $mime_type == 'video/mpg' || $mime_type == 'video/mp4') {
                            $file_type = Feed::FILE_TYPE_VIDEO;
                        } else if ($mime_type == 'application/pdf') {
                            $file_type = Feed::FILE_TYPE_DOCUMENT;
                        }
                    }
    
    
                    $feedMapper = FeedMapper::getInstance($this->adapter);
                    $result = $feedMapper->insert($feed);
    
    
                    if ($result) {
    
                        $feed = $feedMapper->fetchOne($feed->id);
    
                        if ($file_type == Feed::FILE_TYPE_DOCUMENT) {
                            try {
                                $target_path = $this->config['leaderslinked.fullpath.feed'] . $feed->uuid;
                                if (!file_exists($target_path)) {
                                    mkdir($target_path, 0755);
                                }
    
                                $full_filename = $target_path  . DIRECTORY_SEPARATOR . $feed_filename;
                                $result = move_uploaded_file($feed_tmp_filename, $full_filename);
                                if ($result) {
    
                                    $feed->file_type = $file_type;
                                    $feed->file_name = basename($feed_filename);
                                    $feedMapper->update($feed);
                                } else {
                                    error_log('no se pudo mover o renombrar el documento : ' . $feed_tmp_filename . ' al directorio : ' . $full_filename);
                                }
                            } catch (\Throwable $e) {
                                error_log($e->getTraceAsString());
                            }
                        }
                        if ($file_type == Feed::FILE_TYPE_IMAGE) {
                            try {
                                $target_path = $this->config['leaderslinked.fullpath.feed'] . $feed->uuid;
                                if (!file_exists($target_path)) {
                                    mkdir($target_path, 0755);
                                }
    
                                list($target_width, $target_height) = explode('x', $this->config['leaderslinked.image_sizes.feed_image_size']);
    
                                $feed_filename = substr($feed_filename, 0, strrpos($feed_filename, '.'))  . '.png';
                                $crop_to_dimensions = false;
                                if (Image::uploadImage($feed_tmp_filename, $target_path, $feed_filename, $target_width, $target_height, $crop_to_dimensions)) {
                                    $feed->file_type = $file_type;
                                    $feed->file_name = basename($feed_filename);
                                    $feedMapper->update($feed);
                                }
                            } catch (\Throwable $e) {
                                error_log($e->getTraceAsString());
                            }
                        }
                        if ($file_type == Feed::FILE_TYPE_VIDEO) {
                            try {
                                $target_path = $this->config['leaderslinked.fullpath.feed'] . $feed->uuid;
                                if (!file_exists($target_path)) {
                                    mkdir($target_path, 0755);
                                }
    
                                $full_filename = $target_path  . DIRECTORY_SEPARATOR . $feed_filename;
    
                                $result = move_uploaded_file($feed_tmp_filename, $full_filename);
                                if ($result) {
    
                                    $size = $this->config['leaderslinked.image_sizes.feed_image_size'];
                                    $getFromSecound = 2;
    
                                    //extracción del cover
                                    $generateFileName = substr($feed_filename, 0, strrpos($feed_filename, '.'));
                                    $generateFile =  $target_path  . DIRECTORY_SEPARATOR . $generateFileName .  '.png';
                                    $cmd            = "/usr/bin/ffmpeg -i $full_filename -an -ss $getFromSecound -s $size $generateFile";
                                    exec($cmd);
    
    
                                    $feed->file_type = $file_type;
                                    $feed->file_name = basename($feed_filename);
                                    $feed->file_image_preview = basename($generateFile);
                                    $feedMapper->update($feed);
    
                                    $videoConvert = new VideoConvert();
                                    $videoConvert->filename = $full_filename;
                                    $videoConvert->type = VideoConvert::TYPE_FEED;
    
                                    $videoConvertMapper = VideoConvertMapper::getInstance($this->adapter);
                                    $videoConvertMapper->insert($videoConvert);
                                } else {
                                    error_log('no se pudo mover o renombrar el documento : ' . $feed_tmp_filename . ' al directorio : ' . $full_filename);
                                }
                            } catch (\Throwable $e) {
                                error_log($e->getTraceAsString());
                            }
                        }
    
    
                        $response = [
                            'success'   => true,
                            'data'   => $this->renderFeed($feed->id, $now)
                        ];
                    } else {
                        $response = [
                            'success'   => false,
                            'data'   => $feedMapper->getError()
                        ];
                    }
                } else {
                    $messages = [];
                    $form_messages = (array) $form->getMessages();
                    foreach ($form_messages  as $fieldname => $field_messages) {
                        $messages[$fieldname] = array_values($field_messages);
                    }
    
                    $response = [
                        'success'   => false,
                        'data'   => $messages
                    ];
                }
            }
        } else {
            $response = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
        }

        return new JsonModel($response);
    }


    public function timelineAction()
    {

      
       

        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();





        $request = $this->getRequest();
        if ($request->isGet()) {

            $page = (int) $this->params()->fromQuery('page');
            $type   = $this->params()->fromRoute('type');
            $topic_uuid   = $this->params()->fromRoute('topic_id');
            $urgent   = $this->params()->fromRoute('urgent');
            $myt_id =  $this->params()->fromRoute('myt_id');
            $hptg_uuid =  $this->params()->fromRoute('hptg_id');


            if ($hptg_uuid) {


                $highPerformanceTeamsGroupsMapper = HighPerformanceTeamsGroupsMapper::getInstance($this->adapter);
                $now = $highPerformanceTeamsGroupsMapper->getDatebaseNow();
                
                $highPerformanceTeamsGroups = $highPerformanceTeamsGroupsMapper->fetchOneByUuid($hptg_uuid);

                if (!$highPerformanceTeamsGroups) {
                    $data = [
                        'success' => false,
                        'data' => 'ERROR_RECORD_NOT_FOUND'
                    ];

                    return new JsonModel($data);
                }

                if ($highPerformanceTeamsGroups->status != HighPerformanceTeamsGroups::STATUS_ACTIVE) {

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

                $highPerformanceTeamsGroupsMemberMapper = HighPerformanceTeamsGroupsMembersMapper::getInstance($this->adapter);
                $highPerformanceTeamsGroupsMember = $highPerformanceTeamsGroupsMemberMapper->fetchOneByGroupIdAndUserId($highPerformanceTeamsGroups->id, $currentUser->id);
                if ($highPerformanceTeamsGroupsMember) {
                    if ($highPerformanceTeamsGroupsMember->status == HighPerformanceTeamsGroupsMembers::STATUS_ACCEPTED || $highPerformanceTeamsGroupsMember->status == HighPerformanceTeamsGroupsMembers::STATUS_ADDED_BY_ADMIN) {
                        $queryMapper = QueryMapper::getInstance($this->adapter);
                        $select = $queryMapper->getSql()->select(FeedMapper::_TABLE);
                        $select->columns(['id']);
                        $select->where->equalTo('status', Feed::STATUS_PUBLISHED);
                        $select->where->equalTo('company_id', $currentCompany->id);
                        $select->where->equalTo('high_performance_group_id', $highPerformanceTeamsGroups->id);


                        if (isset($topic_uuid)) {
                            $topicMapper = TopicMapper::getInstance($this->adapter);
                            $topic = $topicMapper->fetchOneByUuid($topic_uuid);
                            if ($topic) {
                                if ($topic->status != 'a') {
                                    return new JsonModel([
                                        'success' => false,
                                        'data' => 'ERROR_YOU_DO_NOT_HAVE_ACCESS'
                                    ]);
                                }
                                $select->where->equalTo('topic_id', $topic->id);
                            } else {
                                return new JsonModel([
                                    'success' => false,
                                    'data' => 'ERROR_RECORD_NOT_FOUND'
                                ]);
                            }
                        } else {
                            if (isset($urgent)) {
                                $select->where->equalTo('priority', Feed::PRIORITY_URGENT);
                            } else {
                                $select->where->IsNull('topic_id');
                            }
                        }


                        $select->where->and->equalTo('type', Feed::TYPE_HPTG);
                        $select->order('added_on desc');
                    } else {
                        return new JsonModel([
                            'success' => false,
                            'data' => 'ERROR_UNAUTHORIZED'
                        ]);
                    }
                } else {

                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_RECORD_NOT_FOUND'
                    ]);
                }
            } else if ($myt_id) {
                $feedMapper = FeedMapper::getInstance($this->adapter);
                $now = $feedMapper->getDatebaseNow();
                
                $myt  = $feedMapper->fetchOneByUuid($myt_id);
                $queryMapper = QueryMapper::getInstance($this->adapter);
                $select = $queryMapper->getSql()->select(FeedMapper::_TABLE);
                $select->columns(['id']);
                $select->where->equalTo('status', Feed::STATUS_PUBLISHED);
                $select->where->equalTo('company_id', $currentCompany->id);
                $select->where->equalTo('myt_id', $myt->id);
                $select->where->and->equalTo('type', Feed::TYPE_MYT_ANSWER);
                $select->order('added_on desc');
            } else {

                $queryMapper = QueryMapper::getInstance($this->adapter);
                $now = $queryMapper->getDatebaseNow();
                
                $select = $queryMapper->getSql()->select(FeedMapper::_TABLE);
                $select->columns(['id']);
                $select->where->equalTo('status', Feed::STATUS_PUBLISHED);
                $select->where->equalTo('company_id', $currentCompany->id);
                $select->where->and->equalTo('type', Feed::TYPE_COMPANY);
                $select->order('added_on desc');
                
                //echo $select->getSqlString($this->adapter->platform); exit;
                
            }



            $dbSelect = new DbSelect($select, $this->adapter);
            $paginator = new Paginator($dbSelect);
            $paginator->setCurrentPageNumber($page ? $page : 1);
            $paginator->setItemCountPerPage(10);

            $items = [];
            $feeds = $paginator->getCurrentItems();

            foreach ($feeds as $feed) {
                $items[] = $this->renderFeed($feed->id, $now);
            }

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

        $response = [
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ];


        return new JsonModel($response);
    }

    public function oneFeedAction()
    {
       
       


        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();

        $request = $this->getRequest();
        if ($request->isGet()) {

            $feed_uuid =  $this->params()->fromRoute('id');
            $myt_id =  $this->params()->fromRoute('id');

            if (!isset($feed_uuid)) {
                $data = [
                    'success'   => false,
                    'data'   => 'ERROR_INVALID_PARAMETER'
                ];

                return new JsonModel($data);
            }

            $items = [];
            $feedMapper = FeedMapper::getInstance($this->adapter);
            $now = $feedMapper->getDatebaseNow();
            
            $feed  = $feedMapper->fetchOneByUuid($feed_uuid);

            if (!$feed) {
                $data = [
                    'success' => false,
                    'data' => 'ERROR_RECORD_NOT_FOUND'
                ];

                return new JsonModel($data);
            }

            if ($feed->type == 'mytq') {

                $items = $this->renderFeed($feed->id, $now, $myt_id);

                $response = [
                    'success' => true,
                    'data' => [
                        'item' => $items,
                        'feed_title' => $feed->title,
                        'topic_title' => $feed->description
                    ]
                ];
            } else if ($feed->type == 'myta') {

                $items = $this->renderFeed($feed->id, $now, $myt_id);

                $response = [
                    'success' => true,
                    'data' => [
                        'item' => $items,
                        'feed_title' => $feed->title,
                        'topic_title' => $feed->description
                    ]
                ];
            } else if ($feed->type == 'hptg') {

                $group_uuid =  $this->params()->fromRoute('group_id');
                $topic_uuid   = $this->params()->fromRoute('topic_id');

                if (!isset($topic_uuid)) {

                    $data = [
                        'success'   => false,
                        'data'   => 'ERROR_INVALID_PARAMETER'
                    ];

                    return new JsonModel($data);
                }
                if (!isset($group_uuid)) {

                    $data = [
                        'success'   => false,
                        'data'   => 'ERROR_INVALID_PARAMETER'
                    ];

                    return new JsonModel($data);
                }
                $highPerformanceTeamsGroupsMapper = HighPerformanceTeamsGroupsMapper::getInstance($this->adapter);
                $highPerformanceTeamsGroups = $highPerformanceTeamsGroupsMapper->fetchOneByUuid($group_uuid);

                if (!$highPerformanceTeamsGroups) {
                    $data = [
                        'success' => false,
                        'data' => 'ERROR_RECORD_NOT_FOUND'
                    ];

                    return new JsonModel($data);
                }


                if ($highPerformanceTeamsGroups->status != HighPerformanceTeamsGroups::STATUS_ACTIVE) {

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

                if ($feed->high_performance_group_id != $highPerformanceTeamsGroups->id) {
                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_METHOD_NOT_ALLOWED'
                    ]);
                }

                $topicMapper = TopicMapper::getInstance($this->adapter);
                $topic = $topicMapper->fetchOneByUuid($topic_uuid);

                if (!$topic) {
                    $data = [
                        'success' => false,
                        'data' => 'ERROR_RECORD_NOT_FOUND'
                    ];

                    return new JsonModel($data);
                }

                if ($feed->topic_id != $topic->id) {
                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_METHOD_NOT_ALLOWED'
                    ]);
                }

                $items = $this->renderFeed($feed->id, $now, $group_uuid);

                $response = [
                    'success' => true,
                    'data' => [
                        'item' => $items,
                        'topic_title' => $topic->title,
                        'feed_title' => $feed->title
                    ]
                ];
            }

            return new JsonModel($response);
        }
    }
    /**
     *
     * @param string $str
     * @return string
     */
    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));
    }



    /**
     *
     * @param int $feed_id
     * @param Company $company
     * @return array
     */
    private function renderFeed($feed_id, $now, $group_uuid = '', $myt_id = '')
    {


        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        $currentCompany = $currentUserPlugin->getCompany();

        $companyMapper = CompanyMapper::getInstance($this->adapter);
        $company = $companyMapper->fetchOne($currentCompany->id);

        $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
        $owner = $companyUserMapper->fetchOwnerByCompanyId($currentCompany->id);

        $currentNetworkPlugin = $this->plugin('currentNetworkPlugin');
        $network = $currentNetworkPlugin->getNetwork();

        $acl = $this->getEvent()->getViewModel()->getVariable('acl');

        $feedMapper = FeedMapper::getInstance($this->adapter);
        $feed = $feedMapper->fetchOne($feed_id);


        $params = [
            'id' => $feed->uuid
        ];


        $item = [
            'feed_unique' => uniqid(),
            'feed_uuid' => $feed->uuid,
            'feed_content_type' => $feed->file_type ? $feed->file_type : '',
            'owner_url' =>  'https://' . $network->main_hostname . '/company/view/' . $company->uuid,
            'owner_image' => $this->url()->fromRoute('storage', ['code' => $company->uuid, 'type' => 'company', 'filename' => $company->image]),
            'owner_name' => $company->name,
        ];
        

        
        
        $userMapper = UserMapper::getInstance($this->adapter);
        $user = $userMapper->fetchOne($feed->user_id);


        
        $item['owner_shared'] = $feed->total_shared;
        $item['owner_comments'] = $feed->total_comments;
        
        
        if($feed->file_type == Feed::FILE_TYPE_FAST_SURVEY) {
            $fastSurveyMapper = FastSurveyMapper::getInstance($this->adapter);
            $fastSurvey = $fastSurveyMapper->fetchOne($feed->fast_survey_id);
            
            $owner_description = [
                'question' => $fastSurvey->question,
                'number_of_answers' => $fastSurvey->number_of_answers,
                'answer1' => $fastSurvey->answer1,
                'answer2' => $fastSurvey->answer2,
                'answer3' => $fastSurvey->answer3,
                'answer4' => $fastSurvey->answer4,
                'answer5' => $fastSurvey->answer5,
                'result_type' => $fastSurvey->result_type,
                
            ]; 
             
            if($fastSurvey->expire_on > $now) {
                
                
                
                $owner_description['active'] = 1;
                $owner_description['time_remaining'] =  Functions::getDateDiff($now, $fastSurvey->expire_on);
                
            } else {
                if($fastSurvey->result_type == FastSurvey::RESULT_TYPE_PUBLIC) {
                    $owner_description['votes1'] = $fastSurvey->votes1;
                    $owner_description['votes2'] = $fastSurvey->votes2;
                    $owner_description['votes3'] = $fastSurvey->votes3;
                    $owner_description['votes4'] = $fastSurvey->votes4;
                    $owner_description['votes5'] = $fastSurvey->votes5;
                }
                
                
                $owner_description['active'] = 0;
                $owner_description['time_remaining'] = 0;
            }
            
            
            $item['owner_description'] =  $owner_description;
            
            
            $item['feed_delete_url'] = '';
        } else {
            $item['owner_description'] = strip_tags($feed->description, 'p');
            $item['feed_delete_url'] = $this->url()->fromRoute('feeds/delete',  $params);
        }


        $item['owner_time_elapse'] = Functions::timeAgo($feed->added_on, $now);

        if ($feed->file_type == Feed::FILE_TYPE_IMAGE) {
            $item['owner_file_image'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_name]);
        }
        if ($feed->file_type == Feed::FILE_TYPE_DOCUMENT) {
            $item['owner_file_document'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_name]);
        }
        if ($feed->file_type == Feed::FILE_TYPE_VIDEO) {
            $item['owner_file_image_preview'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_image_preview]);
            $item['owner_file_video'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_name]);
        }

        

        
        if($feed->file_type == Feed::FILE_TYPE_FAST_SURVEY) {
            $item['comment_add_url'] = '';
            $item['comments'] = [];
        } else {
            $commentMapper = CommentMapper::getInstance($this->adapter);
            $records = $commentMapper->fetchAllPublishedByFeedId($feed->id);
            
    
            $comments = [];
            $comment_count = 0;
            foreach ($records as $record) {
                $user = $userMapper->fetchOne($record->user_id);
    
                $comment = [];
                $comment['unique'] = uniqid();
                $comment_count++;
                $comment['comment_index'] = $comment_count;
                $user = $userMapper->fetchOne($record->user_id);
                if ($user->id == $owner->user_id) {
                    $comment['user_image'] = $this->url()->fromRoute('storage', ['type' => 'company',  'code' => $company->uuid, 'filename' =>  $company->image]);
                    $comment['user_url'] =  'https://' . $network->main_hostname . '/company/view/' . $company->uuid;
                    $comment['user_name'] = $company->name;
                } else {
                    $comment['user_image'] = $this->url()->fromRoute('storage', ['type' => 'user',  'code' => $user->uuid, 'filename' =>  $user->image]);
                    $comment['user_url'] = 'https://' . $network->main_hostname . '/profile/view/' . $user->uuid;
                    $comment['user_name'] = $user->first_name . ' ' . $user->last_name;
                }
                $comment['link_delete'] = $this->url()->fromRoute('feeds/comments/delete', ['id' => $feed->uuid, 'comment' => $record->uuid]);
                $comment['link_answer_add'] = $this->url()->fromRoute('feeds/comments/answer', ['id' => $feed->uuid, 'comment' => $record->uuid]);
                $comment['time_elapsed'] = Functions::timeAgo($record->added_on, $now);
                $comment['comment'] = $record->comment;
    
                $records2 = $commentMapper->fetchAllPublishedByCommentId($record->id);
                $answers = [];
                $contador = 0;
                foreach ($records2 as $record2) {
                    $user = $userMapper->fetchOne($record2->user_id);
    
    
                    $answer = [];
                    $answer['unique'] = uniqid();
    
    
                    $user = $userMapper->fetchOne($record2->user_id);
                    if ($user->id == $owner->user_id) {
                        $answer['user_image'] = $this->url()->fromRoute('storage', ['type' => 'company',  'code' => $company->uuid, 'filename' =>  $company->image]);
                        $answer['user_url'] =  'https://' . $network->main_hostname . '/company/view/' . $company->uuid;
                        $answer['user_name'] = $company->name;
                    } else {
                        $answer['user_image'] = $this->url()->fromRoute('storage', ['type' => 'user',  'code' => $user->uuid, 'filename' =>  $user->image]);
                        $answer['user_url'] = 'https://' . $network->main_hostname . '/profile/view/' . $user->uuid;
                        $answer['user_name'] = $user->first_name . ' ' . $user->last_name;
                    }
                    $answer['link_delete'] = $this->url()->fromRoute('feeds/comments/delete', ['id' => $feed->uuid, 'comment' => $record2->uuid]);
                    $answer['time_elapsed'] = Functions::timeAgo($record2->added_on, $now);
                    $answer['comment'] = $record2->comment;
    
                    $records2 = $commentMapper->fetchAllPublishedByCommentId($record2->id);
    
                    $contador++;
                    array_push($answers, $answer);
                }
                $comment['number_answers'] = $contador;
                $comment['answers'] = $answers;
                array_push($comments, $comment);
            }
            $item['comment_add_url'] = $this->url()->fromRoute('feeds/comments', ['id' => $feed->uuid]);
            $item['comments'] = $comments;
        }
        
        //echo '<pre>';
       // print_r($item);
        //echo '</pre>';
        //exit;


        return $item;
    }

    /**
     *
     * @param int $comment_id
     * @return array
     */
    private function renderComment($comment_id, $now)
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();

        $currentNetworkPlugin = $this->plugin('currentNetworkPlugin');
        $network = $currentNetworkPlugin->getNetwork();


        $currentCompany = $currentUserPlugin->getCompany();

        $companyMapper = CompanyMapper::getInstance($this->adapter);
        $company = $companyMapper->fetchOne($currentCompany->id);


        $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
        $owner = $companyUserMapper->fetchOwnerByCompanyId($currentCompany->id);






        $item = [];

        $commentMapper = CommentMapper::getInstance($this->adapter);
        $record = $commentMapper->fetchOne($comment_id);

        $feedMapper = FeedMapper::getInstance($this->adapter);
        $feed = $feedMapper->fetchOne($record->feed_id);

        if ($record) {
            $userMapper = UserMapper::getInstance($this->adapter);


            $item = [];
            $item['unique'] = uniqid();


            $user = $userMapper->fetchOne($record->user_id);
            if ($user->id == $owner->user_id) {
                $item['user_image'] = $this->url()->fromRoute('storage', ['type' => 'company',  'code' => $company->uuid, 'filename' =>  $company->image]);
                $item['user_url'] =  'https://' . $network->main_hostname . '/company/view/' . $company->uuid;
                $item['user_name'] = $company->name;
            } else {
                $item['user_image'] = $this->url()->fromRoute('storage', ['type' => 'user',  'code' => $user->uuid, 'filename' =>  $user->image]);
                $item['user_url'] = 'https://' . $network->main_hostname . '/profile/view/' . $user->uuid;
                $item['user_name'] = $user->first_name . ' ' . $user->last_name;
            }



            $item['link_answer_add'] = $this->url()->fromRoute('feeds/comments/answer', ['id' => $feed->uuid, 'comment' => $record->uuid]);
            $item['link_delete'] = $this->url()->fromRoute('feeds/comments/delete', ['id' => $feed->uuid, 'comment' => $record->uuid]);
            $item['time_elapsed'] = Functions::timeAgo($record->added_on, $now);
            $item['comment'] = $record->comment;
        }
        return $item;
    }

    /**
     *
     * @param string $path
     * @return boolean
     */
    private function deletePath($path)
    {
        try {
            if (is_dir($path)) {
                if ($dh = opendir($path)) {
                    while (($file = readdir($dh)) !== false) {
                        if ($file == '.' || $file == '..') {
                            continue;
                        }
                        unlink($path . DIRECTORY_SEPARATOR . $file);
                    }
                    closedir($dh);
                }

                rmdir($path);
            }
            return true;
        } catch (\Throwable $e) {
            error_log($e->getTraceAsString());
            return false;
        }
    }
}