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\CompanyMapper;
use LeadersLinked\Mapper\CompanyUserMapper;
use LeadersLinked\Form\Feed\CreateFeedForm;
use LeadersLinked\Form\Feed\CommentForm;
use LeadersLinked\Form\Feed\CommentAnswerForm;
use LeadersLinked\Model\Comment;
use LeadersLinked\Mapper\CommentMapper;
use LeadersLinked\Mapper\FeedMapper;
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\FastSurveyMapper;
use LeadersLinked\Model\FastSurvey;
use LeadersLinked\Form\FastSurvey\FastSurveyForm;
use LeadersLinked\Library\Storage;
use LeadersLinked\Library\Functions;

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

        $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 ($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      = \LeadersLinked\Library\Functions::normalizeStringFilename($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/quicktime' ||  $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);
                        
                        
                        $storage = Storage::getInstance($this->config, $this->adapter);
                        $target_path = $storage->getPathFeed();
                        $interal_path   = 'data' . DIRECTORY_SEPARATOR . 'storage' . DIRECTORY_SEPARATOR . 'tmp';
                        if(!file_exists($interal_path)) {
                            mkdir($interal_path, 0775);
                        }
                        if ($file_type == Feed::FILE_TYPE_DOCUMENT) {
                           
                            
                            if ($storage->putFile($target_path, $feed->uuid, $feed_filename)) {
                                $feed->file_type = $file_type;
                                $feed->file_name = $feed_filename;
                                $feedMapper->update($feed);
                            }
                            
                        } else if ($file_type == Feed::FILE_TYPE_IMAGE) {
                            $image = Image::getInstance($this->config);
                            $target_path = $image->getStorage()->getPathFeed();
                            
                            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;
                            $unlink_source = true;
                            
                            if(!$image->uploadProcessChangeSize($feed_tmp_filename, $target_path, $feed->uuid, $feed_filename, $target_width, $target_height, $crop_to_dimensions, $unlink_source)) {
                                $feed->file_type = $file_type;
                                $feed->file_name = $feed_filename;
                                $feedMapper->update($feed);
                            }
                        }
                        if ($file_type == Feed::FILE_TYPE_VIDEO) {
                            try {
                                
                                $full_filename          = $interal_path . DIRECTORY_SEPARATOR. $feed_filename;
                                $poster_filename        = substr($feed_filename, 0, strrpos($feed_filename, '.')).  '.jpg';
                                $poster_full_filename   = $interal_path . DIRECTORY_SEPARATOR . $poster_filename;
                                
                                move_uploaded_file($feed_tmp_filename, $full_filename);
                                
                                $cmd        = "/usr/bin/ffprobe -v error -of flat=s=_ -select_streams v:0 -show_entries stream=height,width,duration  $full_filename";
                                $response   = trim(shell_exec($cmd));
                                
                                $source_duration = 0;
                                $lines = explode("\n", $response);
                                foreach ($lines as $line) {
                                    $line = trim(strtolower($line));
                                    if (strpos($line, 'duration') !== false) {
                                        $values = explode('=', $line);
                                        $source_duration = intval(str_replace($values[1], '#', ''), 10);
                                    }
                                }
                                
                                
                                if ($source_duration == 0) {
                                    $second_extract = '00:00:02';
                                } else {
                                    if ($source_duration > 10) {
                                        $second_extract = '00:00:10';
                                    } else {
                                        $second_extract = '00:00:02';
                                    }
                                }
                                
                                //$imageSize = $this->config['leaderslinked.image_sizes.feed_image_size'];
                                
                                //$cmd = "/usr/bin/ffmpeg -y -i $full_filename  -pix_fmt yuvj422p -deinterlace -an -ss $second_extract -f mjpeg -t 1 -r 1 -y -s $imageSize $generateFile";
                                // $cmd = "/usr/bin/ffmpeg -y -i $full_filename  -pix_fmt yuvj422p -an -ss $second_extract -f mjpeg -t 1 -r 1 -y -s $imageSize $generateFile";
                                $cmd = "/usr/bin/ffmpeg -y -i $full_filename  -pix_fmt yuvj422p -an -ss $second_extract -f mjpeg -t 1 -r 1 -y  $poster_full_filename";
                                exec($cmd);
                                
                                
                                $ok = $this->storage->putFile($target_path, $feed->uuid, $poster_full_filename);
                                $ok = $ok && $this->storage->putFile($target_path, $feed->uuid, $full_filename);
                                
                                if( $ok ) {
                                    
                                    $feed->file_type = $file_type;
                                    $feed->file_name = basename($feed_filename);
                                    $feed->file_image_preview = basename($poster_filename);;
                                    
                                    
                                    
                                    if($feedMapper->update($feed)) {
                                        
                                        $videoConvert               = new VideoConvert();
                                        $videoConvert->uuid         = $feed->uuid;
                                        $videoConvert->filename     = basename($feed_filename);
                                        $videoConvert->type         = VideoConvert::TYPE_FEED;
                                        
                                        $videoConvertMapper = VideoConvertMapper::getInstance($this->adapter);
                                        $videoConvertMapper->insert($videoConvert);
                                    }
                                }
                                
                                // @unlink($full_filename);
                                //@unlink($generate_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');
            $myt_id = $this->params()->fromRoute('myt_id');
            
            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 \Laminas\Paginator\Adapter\DbSelect($select, $this->adapter);
            $paginator = new \Laminas\Paginator\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 int $feed_id
     * @param \LeadersLinked\Model\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
        ];

        $storage = Storage::getInstance($this->config, $this->adapter);
        $path = $storage->getPathFeed();

        $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' => $storage->getCompanyImage($company),
            'owner_name' => $company->name,
        ];
        

        
        
        $userMapper = \LeadersLinked\Mapper\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'] = $storage->getGenericImage($path, $feed->uuid,  $feed->file_name);
        }
        if ($feed->file_type == Feed::FILE_TYPE_DOCUMENT) {
            $item['owner_file_document'] = $storage->getGenericFile($path, $feed->uuid,  $feed->file_name);
        }
        if ($feed->file_type == Feed::FILE_TYPE_VIDEO) {
            $item['owner_file_image_preview'] = $storage->getGenericImage($path, $feed->uuid,  $feed->file_image_preview);
            $item['owner_file_video'] = $$storage->getGenericFile($path, $feed->uuid,  $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'] = $storage->getCompanyImage($company);
                    $comment['user_url'] =  'https://' . $network->main_hostname . '/company/view/' . $company->uuid;
                    $comment['user_name'] = $company->name;
                } else {
                    $comment['user_image'] = $storage->getUserImage($user);
                    $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'] = $storage->getCompanyImage($company);
                        $answer['user_url'] =  'https://' . $network->main_hostname . '/company/view/' . $company->uuid;
                        $answer['user_name'] = $company->name;
                    } else {
                        $answer['user_image'] = $storage->getUserImage( $user);
                        $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;
        }


        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 = \LeadersLinked\Mapper\UserMapper::getInstance($this->adapter);


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

            $storage = Storage::getInstance($this->config, $this->adapter);
            

            $user = $userMapper->fetchOne($record->user_id);
            if ($user->id == $owner->user_id) {
                $item['user_image'] = $storage->getCompanyImage($company);
                $item['user_url'] =  'https://' . $network->main_hostname . '/company/view/' . $company->uuid;
                $item['user_name'] = $company->name;
            } else {
                $item['user_image'] = $storage->getUserImage($user);
                $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;
        }
    }
}