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\JsonModel;

use LeadersLinked\Library\Functions;
use LeadersLinked\Mapper\CompanyUserMapper;
use LeadersLinked\Form\Feed\CreateForm;
use LeadersLinked\Hydrator\ObjectPropertyHydrator;
use LeadersLinked\Model\Feed;
use LeadersLinked\Mapper\FeedMapper;
use LeadersLinked\Library\Image;
use LeadersLinked\Mapper\GroupMapper;
use LeadersLinked\Mapper\UserMapper;
use LeadersLinked\Mapper\CommentMapper;
use LeadersLinked\Mapper\ConnectionMapper;
use LeadersLinked\Mapper\CompanyFollowerMapper;
use LeadersLinked\Mapper\QueryMapper;
use Laminas\Paginator\Paginator;
use Laminas\Paginator\Adapter\DbSelect;
use LeadersLinked\Mapper\LikeMapper;
use LeadersLinked\Model\Like;
use LeadersLinked\Form\Feed\CommentForm;
use LeadersLinked\Model\Comment;
use LeadersLinked\Form\Feed\CreateGroupCompanyForm;
use LeadersLinked\Model\CompanyUser;
use LeadersLinked\Model\VideoConvert;
use LeadersLinked\Mapper\VideoConvertMapper;
use LeadersLinked\Mapper\CompanyMapper;
use LeadersLinked\Model\Company;
use LeadersLinked\Model\Group;
use LeadersLinked\Mapper\GroupMemberMapper;
use LeadersLinked\Model\GroupMember;
use LeadersLinked\Model\Notification;
use LeadersLinked\Mapper\NotificationMapper;
use LeadersLinked\Mapper\UserNotificationSettingMapper;
use LeadersLinked\Mapper\EmailTemplateMapper;
use LeadersLinked\Model\EmailTemplate;
use LeadersLinked\Library\QueueEmail;


class HighPerformanceTeamsGroupFeedController 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()
    {
        
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);
    }
    
    public function commentAction()
    {
        $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);
            }
            
            $dataPost = $request->getPost()->toArray();
            $form = new CommentForm();
            $form->setData($dataPost);
            
            if($form->isValid()) {
                $currentUserPlugin = $this->plugin('currentUserPlugin');
                $currentUser = $currentUserPlugin->getUser();
                
                $dataPost = (array) $form->getData();
                
                $comment = new Comment();
                $comment->comment = $dataPost['comment'];
                $comment->user_id = $currentUser->id;
                $comment->feed_id = $feed->id;
                
                $commentMapper = CommentMapper::getInstance($this->adapter);
                if($commentMapper->insert($comment)) {
                    
                    
                    if($feed->type == Feed::TYPE_UPDATE) {
                        $userMapper = UserMapper::getInstance($this->adapter);
                        $ownerFeed = $userMapper->fetchOne($feed->user_id);
                        
                        $notification = new Notification();
                        $notification->type = Notification::TYPE_COMMENT_MY_FEED;
                        $notification->feed_id = $feed->id;
                        $notification->read     = Notification::NO;
                        $notification->user_id  = $ownerFeed->id;
                        $notification->message  = 'LABEL_COMMENT_MY_FEED';
                        $notification->url      = $this->url()->fromRoute('dashboard',['feed' => $feed->uuid]);
                        
                        $notificationMapper = NotificationMapper::getInstance($this->adapter);
                        $notificationMapper->insert($notification);
                        
                        $userNotificationMapper = UserNotificationSettingMapper::getInstance($this->adapter);
                        $userNotification = $userNotificationMapper->fetchOne($ownerFeed->id);
                        
                        if($userNotification && $userNotification->comment_my_feed)
                        {
                            $emailTemplateMapper = EmailTemplateMapper::getInstance($this->adapter);
                            $emailTemplate = $emailTemplateMapper->fetchOne(EmailTemplate::ID_COMMENT_MY_FEED);
                            
                            if($emailTemplate) {
                                $arrayCont = [
                                    'firstname'             => $currentUser->first_name,
                                    'lastname'              => $currentUser->last_name,
                                    'other_user_firstname'  => $ownerFeed->first_name,
                                    'other_user_lastname'   => $ownerFeed->last_name,
                                    'company_name'          => '',
                                    'group_name'            => '',
                                    'content'               => '',
                                    'code'                  => '',
                                    'link'                  => $this->url()->fromRoute('dashboard',['feed' => $feed->uuid], ['force_canonical' => true])
                                ];
                                
                                $email = new QueueEmail($this->adapter);
                                $email->processEmailTemplate($emailTemplate, $arrayCont, $ownerFeed->email, trim($ownerFeed->first_name . ' ' . $ownerFeed->last_name));
                            }
                        }
                    }
                     
                    $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 shareAction()
    {
        $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);
            }
            
            $dataPost = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());
            $dataPost['company_id'] = $this->params()->fromRoute('company_id');
            $dataPost['group_id'] = $this->params()->fromRoute('group_id');
            $dataPost['shared_feed_id'] = $feed->id;
            

  
            
            $response = $this->postOrShareFeed($dataPost);
            if( $response ['success']) {
                $feedMapper->incTotalShared($feed->id);
                $total_shared = $feedMapper->fetchTotalShared($feed->id);
                
                $response['total_shared'] = $total_shared;
            }
            
            
            return new JsonModel($response);
            
        } else {
            $response = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
        }
        
        return new JsonModel($response);
    }
    
    public function commentDeleteAction()
    {
        $request = $this->getRequest();
        if($request->isPost()) {
            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();
            
            $feed_id = $this->params()->fromRoute('id');
            $comment = $this->params()->fromRoute('comment');
            
            $feedMapper = FeedMapper::getInstance($this->adapter);
            $feed = $feedMapper->fetchOneByUuid($feed_id);
            
            if($feed) {
            
                $commentMapper = CommentMapper::getInstance($this->adapter);
                $comment = $commentMapper->fetchOneByUuid($comment);
                
                if($comment && $comment->feed_id == $feed->id && $comment->user_id == $currentUser->id) {
                    
                    $comment->status = Comment::STATUS_DELETED;
                    
                    if($commentMapper->update($comment)) {
                        
                        $total_comments = $commentMapper->fetchCountCommentByFeedId($comment->feed_id);
                        
                        
                        $feedMapper = FeedMapper::getInstance($this->adapter);
                        $feed = $feedMapper->fetchOne($comment->feed_id);
                        $feed->total_comments = $total_comments;
                        $feedMapper->update($feed);
                        
                        
                        
    
                        
                        $response = [
                            'success' => true,
                            'data' => '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_COMMENT_NOT_FOUND'
                ];
            }
        } else {
            $response = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
        }
        
        return new JsonModel($response);
    }
    
    public function deleteAction()
    {
        $request = $this->getRequest();
        if($request->isPost()) {
            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();
            
            $feed_id =  $this->params()->fromRoute('id');
            
            $feedMapper = FeedMapper::getInstance($this->adapter);
            $feed = $feedMapper->fetchOneByUuid($feed_id);
            
            if($feed) {
                
                if($feed->user_id && $feed->user_id == $currentUser->id) {
                    
                    return new JsonModel($this->deleteFeed($feed));
                } else if ($feed->group_id) {
                    
                    $groupMapper = GroupMapper::getInstance($this->adapter);
                    $group = $groupMapper->fetchOne($feed->group_id);
                    if($group && $group->user_id == $currentUser->id) {
                        return new JsonModel($this->deleteFeed($feed));
                    }
                    
                } else if ($feed->company_id) {
                    $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                    $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($feed->company_id, $currentUser->id);
                    if($companyUser) {
                        if(in_array($companyUser->type, [CompanyUser::TYPE_OWNER, CompanyUser::TYPE_ADMINISTRATOR, CompanyUser::TYPE_MANAGER])) {
                            return new JsonModel($this->deleteFeed($feed));
                        }
                    }
                }
                
                $response = [
                    'success' => false,
                    'data' => ' ERROR_UNAUTHORIZED'
                ];
                
                
            } else {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_FEED_NOT_FOUND'
                ];
            }
            
            return new JsonModel($response);
            
        } else {
            $response = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
        }
        
        return new JsonModel($response);
    }
    
    public function addAction()
    {
        $request = $this->getRequest();
        if($request->isPost()) {
            $dataPost = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());
            $dataPost['company_id'] = $this->params()->fromRoute('company_id');
            $dataPost['group_id'] = $this->params()->fromRoute('group_id');
           
            $response = $this->postOrShareFeed($dataPost);
            
            
            return new JsonModel($response);
            
        } else {
            $response = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
        }
        
        return new JsonModel($response);
    }

    public function postOrShareFeed($dataPost)
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $companyId  = empty($dataPost['company_id']) ? '' : $dataPost['company_id'];
        $groupId    = empty($dataPost['group_id']) ? '' : $dataPost['group_id'];
        
        
        if($groupId || $companyId) {
            $form = new  CreateGroupCompanyForm($this->adapter);
        } else {
            $form = new  CreateForm($this->adapter);
        }
        $form->setData($dataPost);
        if($form->isValid()) {

            
            

            $hydrator = new ObjectPropertyHydrator();
            $feed = new Feed();
            $hydrator->hydrate($dataPost, $feed);

            $company = null; 
            $group = null;

            if($companyId) {
                $companyMapper = CompanyMapper::getInstance($this->adapter);
                $company = $companyMapper->fetchOneByUuid($companyId);
                
   
                if(!$company) {
                    return [
                        'success'   => false,
                        'data'   => 'ERROR_COMPANY_NOT_FOUND'
                    ];
                }
                
                if($company->status != Company::STATUS_ACTIVE) {
                    return [
                        'success'   => false,
                        'data'   => 'ERROR_COMPANY_IS_NOT_ACTIVE'
                    ];
                }
                
                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($company->id, $currentUser->id);
                
                //print_r($companyUser); exit;
                
                
                if(!$companyUser || $companyUser->status != CompanyUser::STATUS_ACCEPTED) {
                    return [
                        'success'   => false,
                        'data'   => 'ERROR_UNAUTHORIZED'
                    ];
                }
                
            }
            
            if($groupId) {
                $groupMapper = GroupMapper::getInstance($this->adapter);
                $group = $groupMapper->fetchOneByUuid($groupId);
                
                if(!$group) {
                    return [
                        'success'   => false,
                        'data'   => 'ERROR_GROUP_NOT_FOUND'
                    ];
                }
                
                if($group->status != Group::STATUS_ACTIVE) {
                    return [
                        'success'   => false,
                        'data'   => 'ERROR_GROUP_IS_NOT_ACTIVE'
                    ];
                }
                
                $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
                $groupMember = $groupMemberMapper->fetchOneByGroupIdAndUserId($group->id, $currentUser->id);
                if(!$groupMember || !in_array($groupMember->status, [GroupMember::STATUS_ACCEPTED, GroupMember::STATUS_AUTO_JOIN])) {
                    return [
                        'success'   => false,
                        'data'   => 'ERROR_UNAUTHORIZED'
                    ];
                }
            }
            
            $feed->company_id   = $company ? $company->id : null;
            $feed->group_id     = $group ? $group->id : null;
            $feed->user_id      = $currentUser->id;
            
            if($companyId) {
                $feed->type = Feed::TYPE_COMPANY;
            } else if ($groupId) {
                $feed->type = Feed::TYPE_GROUP;
            } else {
                $feed->type = Feed::TYPE_UPDATE;      
            }
                
            $posted_or_shared   = $dataPost['posted_or_shared'];
            if($posted_or_shared != Feed::POSTED && $posted_or_shared != Feed::SHARED) {
                return [
                    'success'   => false,
                    'data'      => 'ERROR_SUPPLY_VALID_SHARING_STATUS'
                ];
            }
            $feed->posted_or_shared = $posted_or_shared;
            $feedMapper = FeedMapper::getInstance($this->adapter);
           
            $shared_with = isset($dataPost['shared_with']) ? $dataPost['shared_with'] : Feed::SHARE_WITH_PUBLIC;
            if ($shared_with != Feed::SHARE_WITH_PUBLIC && $shared_with != Feed::SHARE_WITH_CONNECTIONS) {
                return [
                    'status' => false,
                    'error' => 'ERROR_SUPPLY_VALID_SHARING_WITH_TYPE',
                ];
            }
                
            $feed->shared_with = $shared_with;
            if(Feed::SHARED == $feed->posted_or_shared) {
                $shared_feed_id     = empty($dataPost['shared_feed_id']) ? 0 : $dataPost['shared_feed_id'];
                    
                
                $sharedFeed = $feedMapper->fetchOne($shared_feed_id);
                if(!$sharedFeed) {
                    return [
                        'status' => false,
                        'error' => 'ERROR_POST_SHARE',
                    ];
                        
                }
                    
                $feed->shared_feed_id       = $sharedFeed->id;
                $feed->shared_company_id    = $sharedFeed->shared_company_id;
                $feed->shared_group_id      = $sharedFeed->shared_group_id;
                $feed->shared_job_id        = $sharedFeed->shared_job_id;
            } else {
                $sharedFeed = null;
            }

            $feed->status = Feed::STATUS_PUBLISHED;
            $feed->total_comments    = 0;
            $feed->total_shared     = 0;
                
            
            $files = $this->getRequest()->getFiles()->toArray();
            $file_type = '';
            
            $encoding = $this->params()->fromRoute('encoding');
            if($encoding == 'base64') {
        
                
                $fileBase64Name = $this->params()->fromPost('file_base64_name');
                $fileBase64Content = $this->params()->fromPost('file_base64_content');
                
                if($fileBase64Name && $fileBase64Content) {
                
                    try {
                        $fileBase64Content = base64_decode($fileBase64Content);
                        if($fileBase64Content) {
                            $feed_filename      = $this->normalizeString($fileBase64Name);
                            $feed_tmp_filename = 'data' . DIRECTORY_SEPARATOR . 'tmp';
                            if(!file_exists($feed_tmp_filename)) {
                                mkdir($feed_tmp_filename, 0755, true);
                            }
                            
                            

                            $feed_tmp_filename = 'data' . DIRECTORY_SEPARATOR . 'tmp' . DIRECTORY_SEPARATOR . $feed_filename;
                            file_put_contents($feed_tmp_filename, $fileBase64Content);
                            
                            
                            
                            $mime_type = mime_content_type($feed_tmp_filename);
                            //echo '$mime_type = '. $mime_type; exit;
                            
                            
                            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;
                            }
                
                        }
                    } catch(\Exception $e) {
                        
                    }
                }

            } else {
                
                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;
                    }
                }
            }

            
            $result = $feedMapper->insert($feed);
            if($result) {
                
                if($sharedFeed && $sharedFeed->type == Feed::TYPE_UPDATE) {
            
                
                    $userMapper = UserMapper::getInstance($this->adapter);
                    $ownerFeed = $userMapper->fetchOne($sharedFeed->user_id);
                    
                    $notification = new Notification();
                    $notification->type     = Notification::TYPE_SHARE_MY_FEED;
                    $notification->read     = Notification::NO;
                    $notification->user_id  = $ownerFeed->id;
                    $notification->feed_id = $feed->id;
                    $notification->message  = 'LABEL_SHARE_MY_FEED';
                    $notification->url      = $this->url()->fromRoute('dashboard',['feed' => $sharedFeed->uuid]);
                    
                    $notificationMapper = NotificationMapper::getInstance($this->adapter);
                    $notificationMapper->insert($notification);
                    
                    $userNotificationMapper = UserNotificationSettingMapper::getInstance($this->adapter);
                    $userNotification = $userNotificationMapper->fetchOne($ownerFeed->id);
                    
                    if($userNotification && $userNotification->share_my_feed)
                    {
                        $emailTemplateMapper = EmailTemplateMapper::getInstance($this->adapter);
                        $emailTemplate = $emailTemplateMapper->fetchOne(EmailTemplate::ID_SHARE_MY_FEED);
                        
                        if($emailTemplate) {
                            $arrayCont = [
                                'firstname'             => $currentUser->first_name,
                                'lastname'              => $currentUser->last_name,
                                'other_user_firstname'  => $ownerFeed->first_name,
                                'other_user_lastname'   => $ownerFeed->last_name,
                                'company_name'          => '',
                                'group_name'            => '',
                                'content'               => '',
                                'code'                  => '',
                                'link'                  => $this->url()->fromRoute('dashboard',['feed' => $feed->uuid], ['force_canonical' => true])
                            ];
                            
                            $email = new QueueEmail($this->adapter);
                            $email->processEmailTemplate($emailTemplate, $arrayCont, $ownerFeed->email, trim($ownerFeed->first_name . ' ' . $ownerFeed->last_name));
                        }
                    }
                }
                
                
                $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;
                        
                        if($encoding == 'base64') {
                            $resultMoveOrRename = rename($feed_tmp_filename , $full_filename);
                        } else {
                            $resultMoveOrRename = move_uploaded_file($feed_tmp_filename , $full_filename);
                        }
                        
                        if($resultMoveOrRename) {
                              
                            $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;

                        if($encoding == 'base64') {
                            $resultMoveOrRename = rename($feed_tmp_filename , $full_filename);
                        } else {
                            $resultMoveOrRename = move_uploaded_file($feed_tmp_filename , $full_filename);
                        }
                        
                        if($resultMoveOrRename) {
                        
                            $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";
                            $cmd            = "/usr/bin/ffmpeg -i $full_filename -frames:v 1 -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());
                    }
                }


                return [
                    'success'   => true,
                    'data'   => $this->renderFeed($feed->id)
                ];
           } else {
                return [
                    '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);
            }
                    
            return [
                'success'   => false,
               'data'   => $messages
            ];
        }
    }
    
    public function likeAction()
    {
        $id = $this->params()->fromRoute('id');
        
        $request = $this->getRequest();
        if($request->isPost()) {
            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();
            
            $feedMapper = FeedMapper::getInstance($this->adapter);
            $feed = $feedMapper->fetchOneByUuid($id);
            if(!$feed) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }
            
            $likeMapper = LikeMapper::getInstance($this->adapter);
            $like = $likeMapper->fetchOneByFeedIdAndUserId($feed->id, $currentUser->id);
            
            if($like) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_DUPLICATE_ACTION' 
                ];
                return new JsonModel($response);
            }
            
            $like = new Like();
            $like->user_id = $currentUser->id;
            $like->feed_id = $feed->id;
            
            if($likeMapper->insert($like))
            {
                
                $likes = $likeMapper->fetchCountLikeByFeedId($feed->id);
                
                
                
                if($feed->type == Feed::TYPE_UPDATE) {
                    
                    
                    $userMapper = UserMapper::getInstance($this->adapter);
                    $ownerFeed = $userMapper->fetchOne($feed->user_id);
                    
                    $notification = new Notification();
                    $notification->type     = Notification::TYPE_LIKE_MY_FEED;
                    $notification->read     = Notification::NO;
                    $notification->user_id  = $feed->user_id;
                    $notification->feed_id  = $feed->id;
                    $notification->message  = 'LABEL_LIKE_MY_FEED';
                    $notification->url      = $this->url()->fromRoute('dashboard',['feed' => $feed->uuid]);
                    
                    $notificationMapper = NotificationMapper::getInstance($this->adapter);
                    $notificationMapper->insert($notification);
                    
                    $userNotificationMapper = UserNotificationSettingMapper::getInstance($this->adapter);
                    $userNotification = $userNotificationMapper->fetchOne($ownerFeed->id);
                    
                    if($userNotification && $userNotification->like_my_feed)
                    {
                        $emailTemplateMapper = EmailTemplateMapper::getInstance($this->adapter);
                        $emailTemplate = $emailTemplateMapper->fetchOne(EmailTemplate::ID_LIKE_MY_FEED);
                        
                        if($emailTemplate) {
                            $arrayCont = [
                                'firstname'             => $currentUser->first_name,
                                'lastname'              => $currentUser->last_name,
                                'other_user_firstname'  => $ownerFeed->first_name,
                                'other_user_lastname'   => $ownerFeed->last_name,
                                'company_name'          => '',
                                'group_name'            => '',
                                'content'               => '',
                                'code'                  => '',
                                'link'                  => $this->url()->fromRoute('dashboard',['feed' => $feed->uuid], ['force_canonical' => true])
                            ];
                            
                            $email = new QueueEmail($this->adapter);
                            $email->processEmailTemplate($emailTemplate, $arrayCont, $ownerFeed->email, trim($ownerFeed->first_name . ' ' . $ownerFeed->last_name));
                        }
                    }
              
                }
                
                

    
                
                
                
                
                $response = [
                    'success' => true,
                    'data' => [
                        'likes' => $likes
                    ]
                ];
            } else {
                $response = [
                    'success' => false,
                    'data' => $likeMapper->getError()
                ];
            }
            return new JsonModel($response);
            
        }
        
        $response = [
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ];
        return new JsonModel($response);
    }
    
    public function unlikeAction()
    {
        $id = $this->params()->fromRoute('id');
        
        $request = $this->getRequest();
        if($request->isPost()) {
            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();
            
            $feedMapper = FeedMapper::getInstance($this->adapter);
            $feed = $feedMapper->fetchOneByUuid($id);
            if(!$feed) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }
            
            $likeMapper = LikeMapper::getInstance($this->adapter);
            $like = $likeMapper->fetchOneByFeedIdAndUserId($feed->id, $currentUser->id);
            
            if(!$like) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_DUPLICATE_ACTION'
                ];
                return new JsonModel($response);
            }
            
            if($likeMapper->deleteByFeedIdAndUserId($feed->id, $currentUser->id))
            {
                $likes = $likeMapper->fetchCountLikeByFeedId($feed->id);
                
                
                $response = [
                    'success' => true,
                    'data' => [
                        'likes' => $likes
                    ]
                ];
            } else {
                $response = [
                    'success' => false,
                    'data' => $likeMapper->getError()
                ];
            }
            return new JsonModel($response);
            
        }
        
        $response = [
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ];
        return new JsonModel($response);
    }
    
    public function timelineAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
       
        $type   = $this->params()->fromRoute('type');
        if($type == 'user') {
            $id = $currentUser->id;
        } else {
            $id     = $this->params()->fromRoute('id');
        }
        
       

    
    
        
        $request = $this->getRequest();
        if($request->isGet()) {
            
            $page = (int) $this->params()->fromQuery('page');
            
            if($type == 'user') {
                $connectionMapper = ConnectionMapper::getInstance($this->adapter);
                $records = $connectionMapper->fetchAllConnectionsByUser($id);
               
                $connectionIds = [0];
                foreach($records as $record) 
                {
                    if($currentUser->id == $record->request_from) {
                        array_push($connectionIds, $record->request_to);
                    } else {
                        array_push($connectionIds, $record->request_from);
                    }
                }
                array_push($connectionIds, 1);
                
                $companyFollowerMapper = CompanyFollowerMapper::getInstance($this->adapter);
                $records = $companyFollowerMapper->fetchAllByFollowerId($currentUser->id);
                
                $companyIds = [0];
                foreach($records as $record)
                {
                    if(!in_array($record->company_id, $companyIds)) {
                        array_push($companyIds, $record->company_id);
                    }
                }
                
                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                $companyUsers = $companyUserMapper->fetchAllByUserId($currentUser->id);
                
                foreach($companyUsers as $companyUser)
                {
                    if($companyUser->status == CompanyUser::STATUS_ACCEPTED) {
                        if(!in_array($companyUser->company_id, $companyIds)) {
                            array_push($companyIds, $companyUser->company_id);
                        }
                    }
                }
                
                
                $queryMapper = QueryMapper::getInstance($this->adapter);
                $select = $queryMapper->getSql()->select(FeedMapper::_TABLE);
                $select->columns(['id']);
                $select->where->equalTo('status', Feed::STATUS_PUBLISHED)
                    ->AND->NEST
                    ->OR->NEST->equalTo('user_id',$id)->and->equalTo('type', Feed::TYPE_UPDATE)->UNNEST
                    ->OR->NEST->and->equalTo('type', Feed::TYPE_UPDATE)->and->equalTo('shared_with', Feed::SHARE_WITH_PUBLIC)->UNNEST
                    ->OR->NEST->in('user_id', $connectionIds)->and->equalTo('type', Feed::TYPE_UPDATE)->and->equalTo('shared_with', Feed::SHARE_WITH_CONNECTIONS)->UNNEST
                    ->OR->NEST->or->in('company_id', $companyIds)->and->equalTo('type', Feed::TYPE_COMPANY)->UNNEST
                    ->UNNEST;
                $select->order('added_on desc');


            }
            if($type == 'company') {
                $companyMapper = CompanyMapper::getInstance($this->adapter);
                $company = $companyMapper->fetchOneByUuid($id);
          
                if(!$company || $company->status != Company::STATUS_ACTIVE) {
                    $id = 0;
                } else {
                    $companyFollowerMapper = CompanyFollowerMapper::getInstance($this->adapter);
                    $companyFollower = $companyFollowerMapper->fetchOneByCompanyIdAndUserId($company->id, $currentUser->id);
                    if($companyFollower) {
                        $id = $company->id;
                    } else {
                        
                        $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                        $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($company->id, $currentUser->id);
                        
                        if(!$companyUser || $companyUser->status != CompanyUser::STATUS_ACCEPTED) {
                            $id = 0;
                        } else {
                            $id = $company->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',$id);
                $select->where->and->equalTo('type', Feed::TYPE_COMPANY);
                $select->order('added_on desc');
            }
            if($type == 'group') {
               
                $groupMapper = GroupMapper::getInstance($this->adapter);
                $group = $groupMapper->fetchOneByUuid($id);
                if(!$group || $group->status != Group::STATUS_ACTIVE) {
                    $id = 0;
                } else {
                    $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
                    $groupMember = $groupMemberMapper->fetchOneByGroupIdAndUserId($group->id, $currentUser->id);
                    if($groupMember) {
                        $id = $groupMember->status == GroupMember::STATUS_ACCEPTED ? $group->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('group_id',$id);
                $select->where->and->equalTo('type', Feed::TYPE_GROUP);
                $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
     * @return array
     */
    private function renderFeed($feed_id)
    {
       
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $acl = $this->getEvent()->getViewModel()->getVariable('acl');

        $userMapper = UserMapper::getInstance($this->adapter);
        $feedMapper = FeedMapper::getInstance($this->adapter);
        $feed = $feedMapper->fetchOne($feed_id);
        
        
        $likeMapper = LikeMapper::getInstance($this->adapter);
        $like = $likeMapper->fetchOneByFeedIdAndUserId($feed->id, $currentUser->id);
        $likes = $likeMapper->fetchCountLikeByFeedId($feed->id);
       
        $params = [
            'id' => $feed->uuid
        ];
        if($feed->company_id) {
            $companyMapper = CompanyMapper::getInstance($this->adapter);
            $company = $companyMapper->fetchOne($feed->company_id);
            
            $params['company_id'] = $company->uuid;
        } else {
            $company = null;
        }
        if($feed->group_id) {
            $groupMapper = GroupMapper::getInstance($this->adapter);
            $group = $groupMapper->fetchOne($feed->group_id);
            
            $params['group_id'] = $group->uuid;
        } else {
            $group = null;
        }
        
        $item = [
            'feed_unique' => uniqid(),
            'feed_uuid' => $feed->uuid,
            'feed_is_liked' => $like ? true : false,
            'feed_like_url' => $this->url()->fromRoute('feed/like',  $params),
            'feed_unlike_url' => $this->url()->fromRoute('feed/unlike',  $params),
            'feed_share_url' => $this->url()->fromRoute('feed/share',  $params),
            'feed_delete_url' =>  '',
            'feed_content_type' => $feed->file_type ? $feed->file_type : '',
            'feed_likes' =>  $likes,
        ];
        
        if($feed->posted_or_shared == Feed::POSTED) {
        
  
            if($feed->type == Feed::TYPE_COMPANY)
            {
                $companyMapper = CompanyMapper::getInstance($this->adapter);
                $company = $companyMapper->fetchOne($feed->company_id);
                $item['owner_url'] = $this->url()->fromRoute('company/view', ['id' => $company->uuid]);
                $item['owner_image'] = $this->url()->fromRoute('storage', ['code' => $company->uuid, 'type' => 'company', 'filename' => $company->image]);
                $item['owner_name'] = $company->name;
                /*
                 
                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($company->id, $currentUser->id);
                
                
                if( $companyUser && $acl->isAllowed( $currentUser->usertype_id, 'my-company/feed' ) ) {
                    $item['feed_delete_url'] = $this->url()->fromRoute('feed/delete',  $params);
                }
                */
                
                
            } else if($feed->type == Feed::TYPE_GROUP)
            {
                $groupMapper = GroupMapper::getInstance($this->adapter);
                $group = $groupMapper->fetchOne($feed->group_id);
                $item['owner_url'] = '';
                $item['owner_image'] = $this->url()->fromRoute('storage', ['code' => $group->uuid, 'type' => 'group', 'filename' => $group->image]);
                $item['owner_name'] = $group->name;
                
                if($group->user_id == $currentUser->id) {
                    $item['feed_delete_url'] = $this->url()->fromRoute('feed/delete',  $params);
                }
            } else {
                $userMapper = UserMapper::getInstance($this->adapter);
                $user = $userMapper->fetchOne($feed->user_id);
                
                $item['owner_url'] = $this->url()->fromRoute('profile', ['id' => $user->uuid]);
                $item['owner_image'] = $this->url()->fromRoute('storage', ['code' => $user->uuid, 'type' => 'user', 'filename' => $user->image]);
                $item['owner_name'] = $user->first_name . ' ' . $user->last_name;
            
                if($feed->user_id == $currentUser->id) {
                    $item['feed_delete_url'] = $this->url()->fromRoute('feed/delete',  $params);
                }
            
            } 
        } else {
            if($feed->user_id == $currentUser->id) {
                $item['feed_delete_url'] = $this->url()->fromRoute('feed/delete',  $params);
            }
        }
    
        $userMapper = UserMapper::getInstance($this->adapter);
        $user = $userMapper->fetchOne($feed->user_id);
        
        if($feed->posted_or_shared == Feed::SHARED) {
            $item['owner_url'] = $this->url()->fromRoute('profile', ['id' => $user->uuid]);
            $item['owner_image'] = $this->url()->fromRoute('storage', ['code' => $user->uuid, 'type' => 'user', 'filename' => $user->image]);
            $item['owner_name'] = $user->first_name . ' ' . $user->last_name;
        }
        
        $item['owner_description'] = $feed->description;
        
        $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]);
        }
        
        if($feed->posted_or_shared == Feed::SHARED) {
            
            
            $sharedFeed = $feedMapper->fetchOne($feed->shared_feed_id);
            $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $sharedFeed->added_on);
            
            
            $item['shared_description'] = $sharedFeed->description;
            $item['shared_time_elapse'] = Functions::timeElapsedString( $dt->getTimestamp());
            
            if($sharedFeed->file_type == Feed::FILE_TYPE_IMAGE) {
                $item['shared_file_image'] = $this->url()->fromRoute('storage', ['code' => $sharedFeed->uuid, 'type' => 'feed', 'filename' => $sharedFeed->file_name]);
                
            }
            if($sharedFeed->file_type == Feed::FILE_TYPE_DOCUMENT) {
                $item['shared_file_document'] = $this->url()->fromRoute('storage', ['code' => $sharedFeed->uuid, 'type' => 'feed', 'filename' => $sharedFeed->file_name]);
            }
            if($sharedFeed->file_type == Feed::FILE_TYPE_VIDEO) {
                $item['shared_file_image_preview'] = $this->url()->fromRoute('storage', ['code' => $sharedFeed->uuid, 'type' => 'feed', 'filename' => $sharedFeed->file_image_preview]);
                $item['shared_file_video'] = $this->url()->fromRoute('storage', ['code' => $sharedFeed->uuid, 'type' => 'feed', 'filename' => $sharedFeed->file_name]);
            }
            
            $item['shared_content_type'] = $sharedFeed->file_type ? $sharedFeed->file_type : '';
            
            if($feed->company_id)
            {
                
                $companyMapper = CompanyMapper::getInstance($this->adapter);
                $sharedCompany = $companyMapper->fetchOne($feed->company_id);
                $item['shared_url'] = $this->url()->fromRoute('company/view', ['id' => $sharedCompany->uuid]);
                $item['shared_image'] = $this->url()->fromRoute('storage', ['code' => $sharedCompany->uuid, 'type' => 'company', 'filename' => $sharedCompany->image]);
                $item['shared_name'] = $sharedCompany->name;
            } else if($feed->group_id)
            {
                $groupMapper = GroupMapper::getInstance($this->adapter);
                $sharedGroup = $groupMapper->fetchOne($feed->group_id);
                $item['shared_url'] = ''; 
                $item['shared_image'] = $this->url()->fromRoute('storage', ['code' => $sharedGroup->uuid, 'type' => 'group', 'filename' =>  $sharedGroup->image]);
                $item['shared_name'] = $sharedGroup->name;
            } else {
               
                $sharedUser = $userMapper->fetchOne($sharedFeed->user_id);
                $item['shared_url'] = $this->url()->fromRoute('profile', ['id' => $sharedUser->uuid]);
                $item['shared_image'] = $this->url()->fromRoute('storage', ['code' => $sharedUser->uuid, 'type' => 'user', 'filename' => $sharedUser->image]);
                $item['shared_name'] = $sharedUser->first_name . ' ' . $sharedUser->last_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);
            
            if($record->user_id == $currentUser->id) {
                $link_delete = $this->url()->fromRoute('feed/comment/delete',['id' => $feed->uuid, 'comment' => $record->uuid]);
            } else {
                $link_delete = '';
            }
            
            array_push($comments, [
                'unique' => uniqid(),
                'user_url' => $this->url()->fromRoute('profile', ['id' => $user->uuid]),
                'user_name' => $user->first_name . ' ' . $user->last_name,
                'user_image' => $this->url()->fromRoute('storage', ['type' => 'user',  'code' => $user->uuid, 'filename' =>  $user->image ]),
                'time_elapsed' => Functions::timeElapsedString($dt->getTimestamp()),
                'comment' => $record->comment,
                'link_delete' => $link_delete
            ]);
        }
        $item['comment_add_url'] = $this->url()->fromRoute('feed/comment', ['id' => $feed->uuid]);
        $item['comments'] = $comments;
        
        return $item;
    }
    
    /**
     *
     * @param int $comment_id
     * @return array
     */
    private function renderComment($comment_id)
    {
        $item = [];
        
        $commentMapper = CommentMapper::getInstance($this->adapter);
        $record = $commentMapper->fetchOne($comment_id);
        
        $feedMapper = FeedMapper::getInstance($this->adapter);
        $feed = $feedMapper->fetchOne($record->feed_id);
        
        if($record) {
            $userMapper = UserMapper::getInstance($this->adapter);
            
            $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->added_on);
            
            
            $user = $userMapper->fetchOne($record->user_id);
            
            $item['unique'] = uniqid();
            $item['user_image'] = $this->url()->fromRoute('storage', ['type' => 'user',  'code' => $user->uuid, 'filename' =>  $user->image ]);
            $item['user_url'] = $this->url()->fromRoute('profile', ['id' => $user->uuid]);
            $item['user_name'] = $user->first_name . ' ' . $user->last_name;
            $item['time_elapsed'] = Functions::timeElapsedString($dt->getTimestamp());
            $item['comment'] = $record->comment;
            $item['link_delete'] = $this->url()->fromRoute('feed/comment/delete',['id' => $feed->uuid, 'comment' => $record->uuid ]);
        }
        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;
        }
    }
    
    
    /**
     * 
     * @param Feed $feed
     * @return array
     */
    private function deleteFeed($feed) 
    {
        $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()
            ];
        }
        
        
        /*$commentMapper = CommentMapper::getInstance($this->adapter);
        if($commentMapper->deleteAllByFeedId($feed->id)) {
            if($feedMapper->delete($feed->id)) {
                $target_path = $this->config['leaderslinked.fullpath.feed'] . DIRECTORY_SEPARATOR . $feed->id;
                if(file_exists($target_path)) {
                    $this->deletePath($target_path);
                }
                
                $response = [
                    'success' => true,
                    'data' => 'LABEL_FEED_WAS_DELETED'
                ];
                
            } else {
                $response = [
                    'success' => false,
                    'data' => $feedMapper->getError()
                ];
            }
        } else {
            $response = [
                'success' => false,
                'data' => $commentMapper->getError()
            ];
            
        }*/
        
        return $response;
    }
    
 
}