Proyectos de Subversion LeadersLinked - Backend

<?php

/**

 *

 * Controlador: Mis Perfiles

 *

 */

declare(strict_types=1);

namespace LeadersLinked\Controller;

use Laminas\Db\Adapter\AdapterInterface;

use Laminas\Cache\Storage\Adapter\AbstractAdapter;

use Laminas\Mvc\Controller\AbstractActionController;

use Laminas\Log\LoggerInterface;

use Laminas\View\Model\ViewModel;

use Laminas\View\Model\JsonModel;

use LeadersLinked\Mapper\CompanyMapper;

use LeadersLinked\Mapper\CompanyUserMapper;

use LeadersLinked\Form\CreateFeedForm;

use LeadersLinked\Form\CommentForm;

use LeadersLinked\Model\Comment;

use LeadersLinked\Mapper\CommentMapper;

use LeadersLinked\Mapper\FeedMapper;

use LeadersLinked\Mapper\GroupMapper;

use LeadersLinked\Model\Feed;

use LeadersLinked\Mapper\QueryMapper;

use LeadersLinked\Hydrator\ObjectPropertyHydrator;

use LeadersLinked\Library\Image;

use LeadersLinked\Model\VideoConvert;

use LeadersLinked\Mapper\VideoConvertMapper;

use LeadersLinked\Mapper\LikeMapper;

use Laminas\Paginator\Adapter\DbSelect;

use Laminas\Paginator\Paginator;

use LeadersLinked\Mapper\UserMapper;

use LeadersLinked\Library\Functions;

use LeadersLinked\Model\Company;

use LeadersLinked\Model\UserType;

use LeadersLinked\Model\HighPerformanceTeamsGroupsMembers;

use LeadersLinked\Model\HighPerformanceTeamsGroups;

use LeadersLinked\Mapper\HighPerformanceTeamsGroupsMembersMapper;

use LeadersLinked\Mapper\HighPerformanceTeamsGroupsMapper;

class FeedController extends AbstractActionController

{

    /**

     *

     * @var AdapterInterface

     */

    private $adapter;

    /**

     *

     * @var AbstractAdapter

     */

    private $cache;

    /**

     *

     * @var  LoggerInterface

     */

    private $logger;

    /**

     *

     * @var array

     */

    private $config;

    /**

     *

     * @param AdapterInterface $adapter

     * @param AbstractAdapter $cache

     * @param LoggerInterface $logger

     * @param array $config

     */

    public function __construct($adapter, $cache , $logger,  $config)

    {

        $this->adapter      = $adapter;

        $this->cache        = $cache;

        $this->logger       = $logger;

        $this->config       = $config;

    }

    /**

     *

     * 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->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->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 CommentForm();

            $form->setData($dataPost);

            if($form->isValid()) {

                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);

                $owner = $companyUserMapper->fetchOwnerByCompanyId($currentCompany->id);

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

                $comment = new Comment();

                $comment->comment = $dataPost['comment'];

                $comment->user_id = $owner->user_id;

                $comment->feed_id = $feed->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),

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

            }

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

            }

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

        $currentCompany = $currentUserPlugin->getCompany();

        $request = $this->getRequest();

        if($request->isPost()) {

            $dataPost = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());

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

            $form->setData($dataPost);

            if($form->isValid()) {

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

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

                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);

                $owner = $companyUserMapper->fetchOwnerByCompanyId($company->id);

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

                $response = [

                    'success' => false,

                    'data' => $dataPost['type']

                 ];

                return new JsonModel($response);

                $hydrator = new ObjectPropertyHydrator();

                $feed = new Feed();

                $hydrator->hydrate($dataPost, $feed);

                $feed->company_id       = $currentCompany->id;

                $feed->group_id         = null;

                $feed->user_id          = $owner->user_id;

                $feed->type             = Feed::TYPE_COMPANY;

                $feed->posted_or_shared = Feed::POSTED;

                $feed->shared_with      = Feed::SHARE_WITH_CONNECTIONS;

                $feed->total_comments   = 0;

                $feed->total_shared     = 0;

                $files = $this->getRequest()->getFiles()->toArray();

                $file_type = '';

                if(isset($files['file']) && empty($files['file']['error'])) {

                    $feed_tmp_filename  = $files['file']['tmp_name'];

                    $feed_filename      = $this->normalizeString($files['file']['name']);

                    $mime_type = mime_content_type($feed_tmp_filename);

                    if($mime_type == 'image/jpg' || $mime_type == 'image/jpeg' || $mime_type == 'image/png') {

                        $file_type = Feed::FILE_TYPE_IMAGE;

                    } else if($mime_type == 'video/webm' || $mime_type == 'video/mpeg' || $mime_type == 'video/mpg' || $mime_type == 'video/mp4') {

                        $file_type = Feed::FILE_TYPE_VIDEO;

                    } else if($mime_type == 'application/pdf') {

                        $file_type = Feed::FILE_TYPE_DOCUMENT;

                    }

                }

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

                $result = $feedMapper->insert($feed);

                if($result) {

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

                    if( $file_type == Feed::FILE_TYPE_DOCUMENT) {

                        try {

                            $target_path = $this->config['leaderslinked.fullpath.feed'] . $feed->uuid;

                            if(!file_exists($target_path)) {

                                mkdir($target_path, 0755);

                            }

                            $full_filename = $target_path  . DIRECTORY_SEPARATOR .$feed_filename;

                            $result = move_uploaded_file($feed_tmp_filename , $full_filename);

                            if($result) {

                                $feed->file_type = $file_type;

                                $feed->file_name = basename($feed_filename);

                                $feedMapper->update($feed);

                            } else {

                                error_log('no se pudo mover o renombrar el documento : ' . $feed_tmp_filename . ' al directorio : ' . $full_filename );

                            }

                        } catch(\Throwable $e) {

                            error_log($e->getTraceAsString());

                        }

                    }

                    if( $file_type == Feed::FILE_TYPE_IMAGE) {

                        try {

                            $target_path = $this->config['leaderslinked.fullpath.feed'] . $feed->uuid;

                            if(!file_exists($target_path)) {

                                mkdir($target_path, 0755);

                            }

                            list($target_width, $target_height) = explode('x', $this->config['leaderslinked.image_sizes.feed_image_size']);

                            $feed_filename = substr($feed_filename, 0, strrpos($feed_filename, '.'))  . '.png';

                            $crop_to_dimensions = false;

                            if(Image::uploadImage($feed_tmp_filename, $target_path, $feed_filename, $target_width, $target_height, $crop_to_dimensions )) {

                                $feed->file_type = $file_type;

                                $feed->file_name = basename($feed_filename);

                                $feedMapper->update($feed);

                            }

                        } catch(\Throwable $e) {

                            error_log($e->getTraceAsString());

                        }

                    }

                    if( $file_type == Feed::FILE_TYPE_VIDEO) {

                        try {

                            $target_path = $this->config['leaderslinked.fullpath.feed'] . $feed->uuid;

                            if(!file_exists($target_path)) {

                                mkdir($target_path, 0755);

                            }

                            $full_filename = $target_path  . DIRECTORY_SEPARATOR . $feed_filename;

                            $result = move_uploaded_file($feed_tmp_filename , $full_filename);

                            if($result) {

                                $size = $this->config['leaderslinked.image_sizes.feed_image_size'];

                                $getFromSecound = 2;

                                //extracción del cover

                                $generateFileName = substr($feed_filename, 0, strrpos($feed_filename, '.'));

                                $generateFile =  $target_path  . DIRECTORY_SEPARATOR . $generateFileName .  '.png';

                                $cmd            = "/usr/bin/ffmpeg -i $full_filename -an -ss $getFromSecound -s $size $generateFile";

                                exec($cmd);

                                $feed->file_type = $file_type;

                                $feed->file_name = basename($feed_filename);

                                $feed->file_image_preview = basename($generateFile);

                                $feedMapper->update($feed);

                                $videoConvert = new VideoConvert();

                                $videoConvert->filename = $full_filename;

                                $videoConvert->type = VideoConvert::TYPE_FEED;

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

                                $videoConvertMapper->insert($videoConvert);

                            } else {

                                error_log('no se pudo mover o renombrar el documento : ' . $feed_tmp_filename . ' al directorio : ' . $full_filename );

                            }

                        } catch(\Throwable $e) {

                            error_log($e->getTraceAsString());

                        }

                    }

                    $response = [

                        'success'   => true,

                        'data'   => $this->renderFeed($feed->id)

                    ];

                } 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 post($dataPost)

    {

    }

    public function timelineAction()

    {

        $currentUserPlugin = $this->plugin('currentUserPlugin');

        $currentUser = $currentUserPlugin->getUser();

        $currentCompany = $currentUserPlugin->getCompany();

        $request = $this->getRequest();

        if($request->isGet()) {

            $page = (int) $this->params()->fromQuery('page');

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

            if(isset($type)){

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

                $highPerformanceTeamsGroupsMapper = HighPerformanceTeamsGroupsMapper::getInstance($this->adapter);

                $highPerformanceTeamsGroups = $highPerformanceTeamsGroupsMapper->fetchOneByUuid($id);

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

                    $id = 0;

                } else {

                    $highPerformanceTeamsGroupsMemberMapper = HighPerformanceTeamsGroupsMembersMapper::getInstance($this->adapter);

                    $highPerformanceTeamsGroupsMember = $highPerformanceTeamsGroupsMemberMapper->fetchOneByGroupIdAndUserId($highPerformanceTeamsGroups->id, $currentUser->id);

                    if($highPerformanceTeamsGroupsMember) {

                        $id = $highPerformanceTeamsGroupsMember->status == HighPerformanceTeamsGroupsMembers::STATUS_ACCEPTED ? $highPerformanceTeamsGroups->id : 0;

                    } else {

                        $id = 0;

                    }

                }

                $queryMapper = QueryMapper::getInstance($this->adapter);

                $select = $queryMapper->getSql()->select(FeedMapper::_TABLE);

                $select->columns(['id']);

                $select->where->equalTo('status', Feed::STATUS_PUBLISHED);

                $select->where->equalTo('high_performance_group_id',$currentCompany->id);

                $select->where->and->equalTo('type', Feed::TYPE_COMPANY);

                $select->order('added_on desc');

            }else{

                $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->and->equalTo('type', Feed::TYPE_COMPANY);

                $select->order('added_on desc');

            }

            $dbSelect = new DbSelect($select, $this->adapter);

            $paginator = new Paginator($dbSelect);

            $paginator->setCurrentPageNumber($page ? $page : 1);

            $paginator->setItemCountPerPage(10);

            $items = [];

            $feeds = $paginator->getCurrentItems();

            foreach($feeds as $feed)

            {

                $items[] = $this->renderFeed($feed->id);

            }

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

    }

    /**

     *

     * @param string $str

     * @return string

     */

    private function normalizeString ($str = '')

    {

        $basename  = substr($str, 0, strrpos($str, '.'));

        $basename  = str_replace('.', '-', $basename);

        $extension  = substr($str, strrpos($str, '.'));

        $str = $basename . $extension;

        $str = strip_tags($str);

        $str = preg_replace('/[\r\n\t ]+/', ' ', $str);

        $str = preg_replace('/[\"\*\/\:\<\>\?\'\|\,]+/', ' ', $str);

        $str = strtolower($str);

        $str = html_entity_decode( $str, ENT_QUOTES, "utf-8" );

        $str = htmlentities($str, ENT_QUOTES, "utf-8");

        $str = preg_replace("/(&)([a-z])([a-z]+;)/i", '$2', $str);

        $str = str_replace(' ', '-', $str);

        $str = rawurlencode($str);

        $str = str_replace('%', '-', $str);

        return trim(strtolower($str));

    }

    /**

     *

     * @param int $feed_id

     * @param Company $company

     * @return array

     */

    private function renderFeed($feed_id)

    {

        $sandbox = $this->config['leaderslinked.runmode.sandbox'];

        if($sandbox) {

            $company_profile_url = $this->config['leaderslinked.frontend.sandbox_company_profile'];

            $user_profile_url = $this->config['leaderslinked.frontend.sandbox_user_profile'];

        } else {

            $company_profile_url = $this->config['leaderslinked.frontend.production_company_profile'];

            $user_profile_url = $this->config['leaderslinked.frontend.production_user_profile'];

        }

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

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

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

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

        $params = [

            'id' => $feed->uuid

        ];

        $item = [

            'feed_unique' => uniqid(),

            'feed_uuid' => $feed->uuid,

            'feed_delete_url' =>  $this->url()->fromRoute('feeds/delete',  $params),

            'feed_content_type' => $feed->file_type ? $feed->file_type : '',

        ];

        $item['owner_url'] =  str_replace('[uuid]', $company->uuid, $company_profile_url);

        $item['owner_image'] = $this->url()->fromRoute('storage', ['code' => $company->uuid, 'type' => 'company', 'filename' => $company->image]);

        $item['owner_name'] = $company->name;

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

        $user = $userMapper->fetchOne($feed->user_id);

        $item['owner_description'] = strip_tags($feed->description, 'p');

        $item['owner_shared'] = $feed->total_shared;

        $item['owner_comments'] = $feed->total_comments;

        $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $feed->added_on);

        $item['owner_time_elapse'] = Functions::timeElapsedString( $dt->getTimestamp());

        if($feed->file_type == Feed::FILE_TYPE_IMAGE) {

            $item['owner_file_image'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_name]);

        }

        if($feed->file_type == Feed::FILE_TYPE_DOCUMENT) {

            $item['owner_file_document'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_name]);

        }

        if($feed->file_type == Feed::FILE_TYPE_VIDEO) {

            $item['owner_file_image_preview'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_image_preview]);

            $item['owner_file_video'] = $this->url()->fromRoute('storage', ['code' => $feed->uuid, 'type' => 'feed', 'filename' => $feed->file_name]);

        }

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

        $records = $commentMapper->fetchAllPublishedByFeedId($feed->id);

        $comments = [];

        foreach($records as $record)

        {

            $user = $userMapper->fetchOne($record->user_id);

            $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->added_on);

            $comment = [];

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

            $user = $userMapper->fetchOne($record->user_id);

            if($user->id == $owner->user_id) {

                $comment['user_image'] = $this->url()->fromRoute('storage', ['type' => 'company',  'code' => $company->uuid, 'filename' =>  $company->image ]);

                $comment['user_url'] =  str_replace('[uuid]', $company->uuid, $company_profile_url);

                $comment['user_name'] = $company->name;

            } else {

                $comment['user_image'] = $this->url()->fromRoute('storage', ['type' => 'user',  'code' => $user->uuid, 'filename' =>  $user->image ]);

                $comment['user_url'] = str_replace('[uuid]', $user->uuid, $user_profile_url);

                $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['time_elapsed'] = Functions::timeElapsedString($dt->getTimestamp());

            $comment['comment'] = $record->comment;

            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)

    {

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

        $sandbox = $this->config['leaderslinked.runmode.sandbox'];

        if($sandbox) {

            $company_profile_url = $this->config['leaderslinked.frontend.sandbox_company_profile'];

            $user_profile_url = $this->config['leaderslinked.frontend.sandbox_user_profile'];

        } else {

            $company_profile_url = $this->config['leaderslinked.frontend.production_company_profile'];

            $user_profile_url = $this->config['leaderslinked.frontend.production_user_profile'];

        }

        $item = [];

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

        $record = $commentMapper->fetchOne($comment_id);

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

        $feed = $feedMapper->fetchOne($record->feed_id);

        if($record) {

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

            $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->added_on);

            $item = [];

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

            $user = $userMapper->fetchOne($record->user_id);

            if($user->id == $owner->user_id) {

                $item['user_image'] = $this->url()->fromRoute('storage', ['type' => 'company',  'code' => $company->uuid, 'filename' =>  $company->image ]);

                $item['user_url'] =  str_replace('[uuid]', $company->uuid, $company_profile_url);

                $item['user_name'] = $company->name;

            } else {

                $item['user_image'] = $this->url()->fromRoute('storage', ['type' => 'user',  'code' => $user->uuid, 'filename' =>  $user->image ]);

                $item['user_url'] = str_replace('[uuid]', $user->uuid, $user_profile_url);

                $item['user_name'] = $user->first_name . ' ' . $user->last_name;

            }

            $item['link_delete'] = $this->url()->fromRoute('feeds/comments/delete',['id' => $feed->uuid, 'comment' => $record->uuid ]);

            $item['time_elapsed'] = Functions::timeElapsedString($dt->getTimestamp());

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

        }

    }

}