Proyectos de Subversion LeadersLinked - Backend

Rev

Rev 17287 | Autoría | Comparar con el anterior | Ultima modificación | Ver Log | 

<?php

declare(strict_types=1);

namespace LeadersLinked\Controller;

use Laminas\Mvc\Controller\AbstractActionController;
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\Form\FastSurvey\FastSurveyForm;
use LeadersLinked\Model\Comment;
use LeadersLinked\Model\FastSurvey;
use LeadersLinked\Model\Feed;
use LeadersLinked\Mapper\CommentMapper;
use LeadersLinked\Mapper\FeedMapper;
use LeadersLinked\Mapper\QueryMapper;
use LeadersLinked\Hydrator\ObjectPropertyHydrator;
use LeadersLinked\Model\VideoConvert;
use LeadersLinked\Mapper\VideoConvertMapper;
use LeadersLinked\Mapper\FastSurveyMapper;
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()
    {
        $request = $this->getRequest();

        if (!$request->isGet()) {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }

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

    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()
    {
        try {
            $request = $this->getRequest();

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

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

            if (!$request->isPost()) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_METHOD_NOT_ALLOWED'
                ]);
            }

            $feedMapper = FeedMapper::getInstance($this->adapter);
            $feed = $feedMapper->fetchOneByUuidAndNetworkId($id, $currentUser->network_id);

            if (!$feed) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ]);
            }

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

            $feed->status = Feed::STATUS_DELETED;

            if (!$feedMapper->update($feed)) {
                return new JsonModel([
                    'success' => false,
                    'data' => $feedMapper->getError()
                ]);
            }

            return new JsonModel([
                'success' => true,
                'data' => 'LABEL_FEED_WAS_DELETED'
            ]);
        } catch (\Throwable $th) {
            $this->logger->error('Error al eliminar el feed: ' . $th->getMessage(), ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
            return new JsonModel([
                'success'   => false,
                'data'   => $th->getMessage()
            ]);
        }
    }

    // Esta función maneja la acción de agregar un nuevo feed.
    public function addAction()
    {
        try {
            // Obtener el objeto de solicitud actual
            $request = $this->getRequest();

            // Recuperar el usuario y la empresa actuales usando plugins
            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();

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

            $currentCompany = $currentUserPlugin->getCompany();

            // Obtener el ID de MYT de la ruta
            $myt_id =  $this->params()->fromRoute('myt_id');

            // Verificar si la solicitud es una solicitud POST
            if (!$request->isPost()) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_METHOD_NOT_ALLOWED'
                ]);
            }

            // Combinar datos de POST y archivos
            $dataPost = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());
            $feed_content_type = empty($dataPost['feed_content_type']) ? '' :  $dataPost['feed_content_type'];

            // Verificar si el tipo de contenido del feed es una encuesta rápida
            if ($feed_content_type == Feed::FILE_TYPE_FAST_SURVEY) {
                $form = new FastSurveyForm();
                $form->setData($dataPost);

                // Validar el formulario
                if ($form->isValid()) {

                    $dataPost = (array) $form->getData();

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

                    // Hidratar los datos en un objeto FastSurvey
                    $hydrator = new ObjectPropertyHydrator();
                    $fastSurvey = new FastSurvey();
                    $hydrator->hydrate($dataPost, $fastSurvey);

                    // Asignar valores al objeto 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) {
                        // Crear un nuevo objeto Feed
                        $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);

                        // Registrar la acción de agregar la encuesta rápida
                        $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 {
                    // Manejar errores de validación del formulario
                    $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
                    ]);
                }
            }
            // Crear un nuevo formulario de feed
            $form = new CreateFeedForm($this->adapter);

            $form->setData($dataPost);

            // Validar el formulario
            if (!$form->isValid()) {
                $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
                ]);
            }

            $companyMapper = CompanyMapper::getInstance($this->adapter);
            $now = $companyMapper->getDatebaseNow();

            $company = $companyMapper->fetchOne($currentCompany->id);

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

            // Establecer la prioridad del feed
            $dataPost['priority'] =  isset($dataPost['priority']) ? Feed::PRIORITY_URGENT  : '';

            // Hidratar los datos en un objeto Feed
            $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;

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

            // Insertar el nuevo feed en la base de datos
            if (!$feedMapper->insert($feed)) {
                return new JsonModel([
                    'success'   => false,
                    'data'   => $feedMapper->getError()
                ]);
            }

            $feed = $feedMapper->fetchOne($feed->id);

            $storage = Storage::getInstance($this->config, $this->adapter);
            $storage->setFiles($request->getFiles()->toArray());

            // Verificar y establecer el nombre de archivo actual
            if (!$storage->setCurrentFilename('file')) {
                return new JsonModel([
                    'success'   => false,
                    'data'   => 'ERROR_UPLOAD_FILE'
                ]);
            }

            $file_type = $storage->getFileType();

            // Manejar la carga de archivos según el tipo de archivo
            if ($file_type == Feed::FILE_TYPE_DOCUMENT) {
                $tmp_filename = $storage->getTmpFilename();
                $filename = 'feed-' . $feed->uuid . '.pdf';
                $target_filename = $storage->composePathToFilename(
                    Storage::TYPE_FEED,
                    $feed->uuid,
                    $filename
                );

                if (!$storage->putFile($tmp_filename, $target_filename)) {
                    return new JsonModel([
                        'success'   => false,
                        'data'   => 'ERROR_UPLOAD_FILE'
                    ]);
                }

                $feed->file_type = $file_type;
                $feed->file_name = $filename;

                if (!$feedMapper->update($feed)) {
                    return new JsonModel([
                        'success'   => false,
                        'data'   => 'ERROR_UPDATING_FEED'
                    ]);
                }
            }

            if ($file_type == Feed::FILE_TYPE_IMAGE) {
                list($target_width, $target_height) = explode('x', $this->config['leaderslinked.image_sizes.feed_image_size']);

                $tmp_filename = $storage->getTmpFilename();
                $filename = 'feed-' . $feed->uuid . '.png';
                $target_filename = $storage->composePathToFilename(
                    Storage::TYPE_FEED,
                    $feed->uuid,
                    $filename
                );

                if (!$storage->uploadImageResize($tmp_filename, $target_filename, $target_width, $target_height)) {
                    return new JsonModel([
                        'success'   => false,
                        'data'   => 'ERROR_UPLOAD_FILE'
                    ]);
                }

                $feed->file_type = $file_type;
                $feed->file_name = $filename;

                if (!$feedMapper->update($feed)) {
                    return new JsonModel([
                        'success'   => false,
                        'data'   => 'ERROR_UPDATING_FEED'
                    ]);
                }
            }

            if ($file_type == Feed::FILE_TYPE_VIDEO) {
                $tmp_filename = $storage->getTmpFilename();
                $filename = 'feed-' . $feed->uuid . '.mp4';
                $target_filename = $storage->composePathToFilename(
                    Storage::TYPE_FEED,
                    $feed->uuid,
                    $filename
                );

                if (!$storage->putFile($tmp_filename, $target_filename)) {
                    return new JsonModel([
                        'success'   => false,
                        'data'   => 'ERROR_UPLOAD_FILE'
                    ]);
                }

                // Generar el nombre de archivo de la imagen del póster
                $poster_filename = 'feed-' . $feed->uuid . '-poster.png';
                $poster_target_filename = $storage->composePathToFilename(
                    Storage::TYPE_FEED,
                    $feed->uuid,
                    $poster_filename
                );

                // Extraer la imagen del póster del video usando el método de la clase Storage
                if (!$storage->extractPosterFromVideo($target_filename, $poster_target_filename)) {
                    return new JsonModel([
                        'success'   => false,
                        'data'   => 'ERROR_GENERATING_VIDEO_POSTER'
                    ]);
                }

                $feed->file_type = $file_type;
                $feed->file_name = $filename;
                $feed->file_image_preview = $poster_filename;

                if (!$feedMapper->update($feed)) {
                    return new JsonModel([
                        'success'   => false,
                        'data'   => 'ERROR_UPDATING_FEED'
                    ]);
                }

                $videoConvert               = new VideoConvert();
                $videoConvert->uuid         = $feed->uuid;
                $videoConvert->filename     = $filename;
                $videoConvert->type         = VideoConvert::TYPE_FEED;

                $videoConvertMapper = VideoConvertMapper::getInstance($this->adapter);

                try {
                    $videoConvertMapper->insert($videoConvert);
                } catch (\Throwable $th) {
                    $this->logger->err('Error al insertar el video convert: ' . $th->getMessage(), ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                    return new JsonModel([
                        'success'   => false,
                        'data'   => 'ERROR_INSERTING_VIDEO_CONVERT'
                    ]);
                }
            }

            // Devolver la respuesta con el feed renderizado
            return new JsonModel([
                'success'   => true,
                'data'   => $this->renderFeed($feed->id, $now)
            ]);
        } catch (\Throwable $th) {
            // Manejar cualquier error que ocurra durante el proceso
            return new JsonModel([
                'success'   => false,
                'data'   => $th->getMessage()
            ]);
        }
    }

    // Esta función maneja la acción del timeline, que recupera una lista paginada de feeds para la empresa actual.
    public function timelineAction()
    {
        try {
            // Obtener el objeto de solicitud actual
            $request = $this->getRequest();

            // Recuperar el usuario y la empresa actuales usando plugins
            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();
            $currentCompany = $currentUserPlugin->getCompany();

            // Verificar si la solicitud es una solicitud GET
            if (!$request->isGet()) {
                return new JsonModel([
                    'success' => false,
                    'data' => 'ERROR_METHOD_NOT_ALLOWED'
                ]);
            }

            // Obtener el número de página de los parámetros de consulta
            $page = (int) $this->params()->fromQuery('page');
            $myt_id = $this->params()->fromRoute('myt_id');

            // Inicializar mappers para consultar la base de datos
            $queryMapper = QueryMapper::getInstance($this->adapter);
            $feedMapper = FeedMapper::getInstance($this->adapter);

            // Verificar si se proporciona un ID de MYT específico
            if ($myt_id) {
                // Obtener la fecha y hora actuales de la base de datos
                $now = $feedMapper->getDatebaseNow();
                // Obtener el feed MYT por UUID
                $myt = $feedMapper->fetchOneByUuid($myt_id);

                // Si no se encuentra el feed MYT, devolver un error
                if (!$myt) {
                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_MYT_NOT_FOUND'
                    ]);
                }

                // Crear una consulta select para respuestas MYT
                $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->equalTo('type', Feed::TYPE_MYT_ANSWER);
                $select->order('added_on desc');
            } else {
                // Obtener la fecha y hora actuales de la base de datos
                $now = $queryMapper->getDatebaseNow();

                // Crear una consulta select para feeds de la empresa
                $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('type', Feed::TYPE_COMPANY);
                $select->order('added_on desc');
            }

            // Crear un paginador para la consulta select
            $dbSelect = new \Laminas\Paginator\Adapter\DbSelect($select, $this->adapter);
            $paginator = new \Laminas\Paginator\Paginator($dbSelect);
            $paginator->setCurrentPageNumber($page ? $page : 1);
            $paginator->setItemCountPerPage(10);

            // Inicializar un array para contener los elementos del feed renderizados
            $items = [];
            // Obtener los elementos actuales del paginador
            $feeds = $paginator->getCurrentItems();

            // Renderizar cada elemento del feed
            foreach ($feeds as $feed) {
                $renderedFeed = $this->renderFeed($feed->id, $now);
                if ($renderedFeed) {
                    $items[] = $renderedFeed;
                }
            }

            // Devolver la respuesta con los elementos del feed paginados
            return new JsonModel([
                'success' => true,
                'data' => [
                    'total' => [
                        'count' => $paginator->getTotalItemCount(),
                        'pages' => $paginator->getPages()->pageCount,
                    ],
                    'current' => [
                        'items'    => $items,
                        'page'     => $paginator->getCurrentPageNumber(),
                        'count'    => $paginator->getCurrentItemCount(),
                    ]
                ]
            ]);
        } catch (\Throwable $th) {
            // Registrar cualquier error que ocurra durante el proceso
            $this->logger->error('Error al obtener el timeline: ' . $th->getMessage(), ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
            // Devolver una respuesta de error
            return new JsonModel([
                'success' => false,
                'data' => $th->getMessage()
            ]);
        }
    }

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