Proyectos de Subversion LeadersLinked - Services

<?php
declare(strict_types=1);

namespace LeadersLinked\Controller;

use Laminas\Mvc\Controller\AbstractActionController;
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\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\ContentReactionMapper;
use LeadersLinked\Model\ContentReaction;
use LeadersLinked\Form\Feed\CommentForm;
use LeadersLinked\Model\Comment;
use LeadersLinked\Form\Feed\CreateGroupCompanyForm;
use LeadersLinked\Model\CompanyUser;
use LeadersLinked\Model\FastSurvey;
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;
use LeadersLinked\Mapper\FastSurveyMapper;
use LeadersLinked\Mapper\FastSurveyVoteMapper;
use LeadersLinked\Model\FastSurveyVote;
use LeadersLinked\Mapper\AbuseReportMapper;
use LeadersLinked\Mapper\UserBlockedMapper;
use LeadersLinked\Model\AbuseReport;
use LeadersLinked\Model\User;
use LeadersLinked\Library\Storage;
use LeadersLinked\Model\VideoConvert;
use LeadersLinked\Mapper\VideoConvertMapper;


class FeedController extends AbstractActionController
{
    /**
     *
     * @var \Laminas\Db\Adapter\AdapterInterface
     */
    private $adapter;
    
    /**
     *
     * @var \LeadersLinked\Cache\CacheInterface
     */
    private $cache;
    
    
    /**
     *
     * @var \Laminas\Log\LoggerInterface
     */
    private $logger;
    
    /**
     *
     * @var array
     */
    private $config;
    
    
    /**
     *
     * @var \Laminas\Mvc\I18n\Translator
     */
    private $translator;
    

    
    
    /**
     *
     * @param \Laminas\Db\Adapter\AdapterInterface $adapter
     * @param \LeadersLinked\Cache\CacheInterface $cache
     * @param \Laminas\Log\LoggerInterface LoggerInterface $logger
     * @param array $config
     * @param \Laminas\Mvc\I18n\Translator $translator
     */
    public function __construct($adapter, $cache, $logger, $config, $translator)
    {
        $this->adapter      = $adapter;
        $this->cache        = $cache;
        $this->logger       = $logger;
        $this->config       = $config;
        $this->translator   = $translator;
  
    }

    /**
     * 
     * Generación del listado de perfiles
     * {@inheritDoc}
     * @see \Laminas\Mvc\Controller\AbstractActionController::indexAction()
     */
    public function indexAction()
    {

        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);
            $now = $feedMapper->getDatebaseNow();
            
            $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->network_id = $currentUser->network_id;
                $comment->comment = $dataPost['comment'];
                $comment->user_id = $currentUser->id;
                $comment->feed_id = $feed->id;
                $comment->relational = Comment::RELATIONAL_FEED;

                $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->fetchOneByCodeAndNetworkId(EmailTemplate::CODE_COMMENT_MY_FEED,  $currentUser->network_id);

                            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, $now),
                        'total_comments' => $total_comments
                    ];

                    return new JsonModel($response);
                } else {

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

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

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

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

            return new JsonModel($response);
        }
    }
    
    public function reactionsAction()
    {
        $id = $this->params()->fromRoute('id');
        
        $request = $this->getRequest();
        $request = $this->getRequest();
        if ($request->isGet()) {

            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();
            
            
            $storage = \LeadersLinked\Library\Storage::getInstance($this->config, $this->adapter);
            
            $feedMapper = FeedMapper::getInstance($this->adapter);
            $feed = $feedMapper->fetchOneByUuidAndNetworkId($id, $currentUser->network_id);
            if (!$feed) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }
            
            
            $userMapper = UserMapper::getInstance($this->adapter);
            
            $items = [];
            
            $contentReactionMapper = ContentReactionMapper::getInstance($this->adapter);
            $records = $contentReactionMapper->fetchAllByFeedId($feed->id);
           
            
            foreach($records as $record)
            {
                $user = $userMapper->fetchOne($record->user_id);
                if($user && $user->status == User::STATUS_ACTIVE) {
             
                    
                    array_push($items, [
                        'first_name'    => $user->first_name,
                        'last_name'     => $user->last_name,
                        'email'         => $user->email,
                        'image'         => $storage->getUserImage($user),
                        'reaction'      => $record->reaction,
                    ]);
                }
            }
            
            $response = [
                'success' => true,
                'data' => $items
            ];
            
            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()) {

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


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

            $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->fetchOneByUuidAndNetworkId($feed_id, $currentUser->network_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->fetchOneByUuidAndNetworkId($feed_id, $currentUser->network_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);
                $now = $companyMapper->getDatebaseNow();
                
                $company = $companyMapper->fetchOneByUuidAndNetworkId($companyId, $currentUser->network_id);


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


                if (!$companyUser || $companyUser->status != CompanyUser::STATUS_ACCEPTED) {
                    return [
                        'success'   => false,
                        'data'   => 'ERROR_UNAUTHORIZED'
                    ];
                }
            }

            if ($groupId) {
                $groupMapper = GroupMapper::getInstance($this->adapter);
                $now = $groupMapper->getDatebaseNow();
                
                $group = $groupMapper->fetchOneByUuidAndNetworkId($groupId, $currentUser->network_id);

                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->network_id   = $currentUser->network_id;
            $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);
            $now = $feedMapper->getDatebaseNow();

            $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->fetchOneByIdAndNetworkId($shared_feed_id, $currentUser->network_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;

            $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->fetchOneByCodeAndNetworkId(EmailTemplate::CODE_SHARE_MY_FEED, $currentUser->network_id);

                        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);
                
                $storage = Storage::getInstance($this->config, $this->adapter);
                $storage->setFiles($this->getRequest()->getFiles()->toArray());
                
                if($storage->setCurrentFilename('file')) {
                    $file_type          = $storage->getFileType();
                    $source_filename    = $storage->getTmpFilename();
                    $filename           = $storage->getFilename();
                    
                    
                    if ($file_type == Storage::FILE_TYPE_DOCUMENT) {
                        
                        $target_filename = $storage->composePathToFilename(Storage::TYPE_FEED, $feed->uuid, $filename);
                        
                        
                        if ($storage->putFile($source_filename,$target_filename)) {
                            $feed->file_type = $file_type;
                            $feed->file_name = $filename;
                            $feedMapper->update($feed);
                        }
                        
                    } else if ($file_type == Storage::FILE_TYPE_IMAGE) {
                        $filename = $storage->getFilenamePNG();
                        $target_filename = $storage->composePathToFilename(Storage::TYPE_FEED, $feed->uuid, $filename);
                        
                        list($target_width, $target_height) = explode('x', $this->config['leaderslinked.image_sizes.feed_image_size']);
                        
                        if($storage->uploadImageResize($source_filename, $target_filename, $target_width, $target_height)) {
                            $feed->file_type = $file_type;
                            $feed->file_name = $filename;
                            $feedMapper->update($feed);
                        }
                    } else if ($file_type == Storage::FILE_TYPE_VIDEO) {
                        
                        $source_filename    = $storage->getTmpFilename();
                        $filename           = $storage->getFilename();
                        
                        $target_filename    = $storage->composePathToFilename(Storage::TYPE_FEED, $feed->uuid, $filename);
                        
                        if($storage->moveUploadedFile($source_filename, $target_filename )) {
                            $feed->file_type = $file_type;
                            $feed->file_name = $filename;
                            
                            $filename           = $storage->getFilenamePNG();
                            $source_poster_filename    = $target_filename;
                            $target_poster_filename    = $storage->composePathToFilename(Storage::TYPE_FEED, $feed->uuid, $filename);
                            
                            if($storage->extractPosterFromVideo($source_poster_filename, $target_poster_filename)) {
                                $feed->file_image_preview = $filename;
                            }
                            
                            
                            if($feedMapper->update($feed)) {
                                $videoConvert               = new VideoConvert();
                                $videoConvert->uuid         = $feed->uuid;
                                $videoConvert->filename     = $feed->file_name;
                                $videoConvert->type         = VideoConvert::TYPE_FEED;
                                
                                $videoConvertMapper = VideoConvertMapper::getInstance($this->adapter);
                                $videoConvertMapper->insert($videoConvert);
                            }
                        }

                    }
                    
                }

                return [
                    'success'   => true,
                    'data'   => $this->renderFeed($feed->id, $now)
                ];
            } 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 saveReactionAction()
    {
        $id = $this->params()->fromRoute('id');
       // $reaction  = $this->params()->fromRoute('reaction');
        $reaction  = $this->params()->fromPost('reaction');

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


            $feedMapper = FeedMapper::getInstance($this->adapter);
            $feed = $feedMapper->fetchOneByUuidAndNetworkId($id, $currentUser->network_id);
            if (!$feed) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }
            
            $reactions = [
                ContentReaction::REACTION_RECOMMENDED,
                ContentReaction::REACTION_SUPPORT,
                ContentReaction::REACTION_LOVE,
                ContentReaction::REACTION_INTEREST,
                ContentReaction::REACTION_FUN
                
            ];
            if(!in_array($reaction, $reactions)) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_REACTION_NOT_FOUND'
                ];
                return new JsonModel($response);
            }
            
            
            $contentReactionMapper = ContentReactionMapper::getInstance($this->adapter);
            $contentReaction = $contentReactionMapper->fetchOneByFeedIdAndUserId($feed->id, $currentUser->id);

            if ($contentReaction) {
                $contentReaction->reaction = $reaction;
                $result = $contentReactionMapper->update($contentReaction);
            } else {
                $contentReaction = new ContentReaction();
                $contentReaction->user_id = $currentUser->id;
                $contentReaction->feed_id = $feed->id;
                $contentReaction->relational = ContentReaction::RELATIONAL_FEED;
                $contentReaction->reaction = $reaction;

                $result = $contentReactionMapper->insert($contentReaction);
            }



            if ($result) {

                $reactions = $contentReactionMapper->fetchCountByFeedId($feed->id);
                $response = [
                    'success' => true,
                    'data' => [
                        'reactions' => $reactions
                    ]
                ];
            } else {
                $response = [
                    'success' => false,
                    'data' => $contentReactionMapper->getError()
                ];
            }
            return new JsonModel($response);
        }

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

    public function deleteReactionAction()
    {
        $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->fetchOneByUuidAndNetworkId($id, $currentUser->network_id);
            if (!$feed) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }

            $contentReactionMapper = ContentReactionMapper::getInstance($this->adapter);
            $contentReaction = $contentReactionMapper->fetchOneByFeedIdAndUserId($feed->id, $currentUser->id);

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

            if ($contentReactionMapper->deleteByFeedIdAndUserId($feed->id, $currentUser->id)) {
                $reactions = $contentReactionMapper->fetchCountByFeedId($feed->id);


                $response = [
                    'success' => true,
                    'data' => [
                        'reactions' => $reactions
                    ]
                ];
            } else {
                $response = [
                    'success' => false,
                    'data' => $contentReactionMapper->getError()
                ];
            }
            return new JsonModel($response);
        }

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

    /*
    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->fetchOneByUuidAndNetworkId($id, $currentUser->network_id);
            if (!$feed) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }

            $contentReactionMapper = ContentReactionMapper::getInstance($this->adapter);
            $contentReaction =  $contentReactionMapper->fetchOneByFeedIdAndUserId($feed->id, $currentUser->id);

            if ($contentReaction) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_DUPLICATE_ACTION'
                ];
                return new JsonModel($response);
            }

            $contentReaction = new Like();
            $contentReaction->user_id = $currentUser->id;
            $contentReaction->feed_id = $feed->id;
            $contentReaction->relational = Like::RELATIONAL_FEED;

            if ($contentReactionMapper->insert($contentReaction)) {

                $contentReactions = $contentReactionMapper->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->fetchOneByCodeAndNetworkId(EmailTemplate::CODE_LIKE_MY_FEED, $currentUser->network_id);

                        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' => $contentReactions
                    ]
                ];
            } else {
                $response = [
                    'success' => false,
                    'data' => $contentReactionMapper->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->fetchOneByUuidAndNetworkId($id, $currentUser->network_id);
            if (!$feed) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }

            $contentReactionMapper = LikeMapper::getInstance($this->adapter);
            $contentReaction = $contentReactionMapper->fetchOneByFeedIdAndUserId($feed->id, $currentUser->id);

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

            if ($contentReactionMapper->deleteByFeedIdAndUserId($feed->id, $currentUser->id)) {
                $contentReactions = $contentReactionMapper->fetchCountLikeByFeedId($feed->id);


                $response = [
                    'success' => true,
                    'data' => [
                        'likes' => $contentReactions
                    ]
                ];
            } else {
                $response = [
                    'success' => false,
                    'data' => $contentReactionMapper->getError()
                ];
            }
            return new JsonModel($response);
        }

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

    public function timelineAction()
    {
        $request = $this->getRequest();

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

        $type   = $this->params()->fromRoute('type');
        $id = $type == 'user' ? $currentUser->id : $this->params()->fromRoute('id');
        $feedUuid = $this->params()->fromRoute('feed');

        $feedHighlighted = 0;

        if ($feedUuid) {
            $feedMapper = FeedMapper::getInstance($this->adapter);
            $now = $feedMapper->getDatebaseNow();
            
            $feed = $feedMapper->fetchOneByUuidAndNetworkIdAnyStatus($feedUuid, $currentUser->network_id);

            if ($feed) {
                $feedHighlighted = $feed->id;
            }
        }



        if ($request->isGet()) {
            $userBlockedMapper = UserBlockedMapper::getInstance($this->adapter);
            $user_blocked_ids = $userBlockedMapper->fetchAllBlockedReturnIds($currentUser->id);
            
            $abuseReportMapper = AbuseReportMapper::getInstance($this->adapter);
            $abuse_report_feed_ids = $abuseReportMapper->fetchAllDataByUserReportingIdAndTypeReturnIds($currentUser->id, AbuseReport::TYPE_FEED);
            
            $abuse_report_comment_ids = $abuseReportMapper->fetchAllDataByUserReportingIdAndTypeReturnIds($currentUser->id, AbuseReport::TYPE_COMMENT);
            
            $exclude_feed_ids = [];
            
            $queryMapper = QueryMapper::getInstance($this->adapter);
            
            $selectNotUserCompany = $queryMapper->getSql()->select();
            $selectNotUserCompany->columns(['company_id']);
            $selectNotUserCompany->from(['cu' => CompanyUserMapper::_TABLE]);
  
            $selectNotUserCompany->where->equalTo('user_id', $currentUser->id);
            $selectNotUserCompany->where->in('status', [CompanyUser::STATUS_ACCEPTED, CompanyUser::STATUS_ADMIN_WILL_ADD]);
            
            $select = $queryMapper->getSql()->select();
            $select->columns(['id']);
            $select->from(['f' => FeedMapper::_TABLE]);
            $select->join(['fs' => FastSurveyMapper::_TABLE], 'fs.id = f.fast_survey_id', []);
            $select->where->equalTo('f.file_type', Feed::FILE_TYPE_FAST_SURVEY);
            $select->where->equalTo('f.network_id', $currentUser->network_id);
            $select->where->equalTo('f.status', Feed::STATUS_PUBLISHED);
            $select->where->equalTo('fs.privacy', FastSurvey::PRIVACY_COMPANY);
            $select->where->notIn('fs.company_id', $selectNotUserCompany);
            
            $records = $queryMapper->fetchAll($select);
            foreach($records as $record)
            {
                array_push($exclude_feed_ids, $record['id']);
            }
            

            $page = (int) $this->params()->fromQuery('page');
            if ($type == 'user') {
                $connectionMapper = ConnectionMapper::getInstance($this->adapter);
                $now = $connectionMapper->getDatebaseNow();
                
                $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);
                        }
                    }
                }


                $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
                $groupMembers = $groupMemberMapper->fetchAllByUserId($currentUser->id);

                $groupIds = [0];

                foreach ($groupMembers as $groupMember) {
                    if ($groupMember->status == GroupMember::STATUS_ACCEPTED) {
                        if (!in_array($groupMember->group_id, $groupIds)) {
                            array_push($groupIds, $groupMember->group_id);
                        }
                    }
                }

                $queryMapper = QueryMapper::getInstance($this->adapter);
                $select = $queryMapper->getSql()->select(FeedMapper::_TABLE);
                $select->columns(['id']);
                $select->where->equalTo('network_id', $currentUser->network_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
                    ->OR->NEST->or->in('group_id', $groupIds)->and->equalTo('type', Feed::TYPE_GROUP)->UNNEST
                    ->UNNEST;
                
                if($exclude_feed_ids) {
                    $select->where->notIn('id', $exclude_feed_ids);        
                }
                if($abuse_report_feed_ids) {
                    $select->where->notIn('id', $abuse_report_feed_ids);
                }
                if($user_blocked_ids) {
                    $select->where->notIn('user_id', $user_blocked_ids);
                }
                    
                    
                $select->order('added_on desc');
            }
            if ($type == 'company') {
                $companyMapper = CompanyMapper::getInstance($this->adapter);
                $now = $companyMapper->getDatebaseNow();
                
                $company = $companyMapper->fetchOneByUuidAndNetworkId($id, $currentUser->network_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;
                        }
                    }
                }
                

               
                $select = $queryMapper->getSql()->select(FeedMapper::_TABLE);
                $select->columns(['id']);
                $select->where->equalTo('network_id', $currentUser->network_id);
                $select->where->equalTo('status', Feed::STATUS_PUBLISHED);
                $select->where->equalTo('company_id', $id);
                $select->where->and->equalTo('type', Feed::TYPE_COMPANY);
                
                if($exclude_feed_ids) {
                    $select->where->notIn('id', $exclude_feed_ids);
                }
                if($abuse_report_feed_ids) {
                    $select->where->notIn('id', $abuse_report_feed_ids);
                }
                if($user_blocked_ids) {
                    $select->where->notIn('user_id', $user_blocked_ids);
                }
                
                $select->order('added_on desc');
            }
            if ($type == 'group') {
                $groupMapper = GroupMapper::getInstance($this->adapter);
                $now = $groupMapper->getDatebaseNow();
                
                $group = $groupMapper->fetchOneByUuidAndNetworkId($id, $currentUser->network_id);

                $id = 0;

                if ($group && $group->status == Group::STATUS_ACTIVE) {
                    $groupMemberMapper = GroupMemberMapper::getInstance($this->adapter);
                    $groupMember = $groupMemberMapper->fetchOneByGroupIdAndUserId($group->id, $currentUser->id);
                    if ($groupMember) {


                        if (
                            $groupMember->status == GroupMember::STATUS_ACCEPTED ||
                            $groupMember->status == GroupMember::STATUS_AUTO_JOIN
                        ) {

                            $id =  $groupMember->group_id;
                        }
                    }
                }

                $queryMapper = QueryMapper::getInstance($this->adapter);
                $select = $queryMapper->getSql()->select(FeedMapper::_TABLE);
                $select->columns(['id']);
                $select->where->equalTo('network_id', $currentUser->network_id);
                $select->where->equalTo('status', Feed::STATUS_PUBLISHED);
                $select->where->equalTo('group_id', $id);
                $select->where->nest()->equalTo('type', Feed::TYPE_GROUP)
                ->or->equalTo('type', Feed::TYPE_UPDATE)->unnest();
                
                if($exclude_feed_ids) {
                    $select->where->notIn('id', $exclude_feed_ids);
                }
                if($abuse_report_feed_ids) {
                    $select->where->notIn('id', $abuse_report_feed_ids);
                }
                if($user_blocked_ids) {
                    $select->where->notIn('user_id', $user_blocked_ids);
                }
                
                $select->order('added_on desc');
            }

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

            $items = [];


            if ($feedHighlighted) {


                $items[] = $this->renderFeed($feedHighlighted, $now, $feedHighlighted,  $user_blocked_ids , $abuse_report_comment_ids);
            }

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

            $response = [
                'success' => true,
                'data' => [
                    'total' => [
                        'count' => $paginator->getTotalItemCount(),
                        'pages' => $paginator->getPages()->pageCount,
                    ],
                    'current' => [
                        'items'    => $items,
                        'page'     => $paginator->getCurrentPageNumber(),
                        'count'    => $paginator->getCurrentItemCount(),
                    ]
                ]
            ];



            /*
            if($feedHighlighted) {
                

                $items[] = $this->renderFeed($feedHighlighted, $now, $feedHighlighted);
                
                $response = [
                    'success' => true,
                    'data' => [
                        'total' => [
                            'count' => 1,
                            'pages' => 1,
                        ],
                        'current' => [
                            'items'    => $items,
                            'page'     => 1,
                            'count'    => 1,
                        ]
                    ]
                ];
            } else {
            
            
            
                $feeds = $paginator->getCurrentItems();
                foreach($feeds as $feed) 
                {
                    $items[] = $this->renderFeed($feed->id, $now, $feedHighlighted);
                }
                
                $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 int $feed_id
     * @param int[] $user_blocked_ids
     * @param int[] $abuse_report_comment_ids
     * @return array
     */
    private function renderFeed($feed_id, $now, $feedHighlighted = 0,  $user_blocked_ids  = [], $abuse_report_comment_ids = [])
    {

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

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

        //$currentCompany = $currentUserPlugin->getCompany();

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

        $userMapper = UserMapper::getInstance($this->adapter);
        $feedMapper = FeedMapper::getInstance($this->adapter);
        $feed = $feedMapper->fetchOneAnyStatus($feed_id);

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

        /*
        $contentReactionMapper = LikeMapper::getInstance($this->adapter);
        $contentReaction = $contentReactionMapper->fetchOneByFeedIdAndUserId($feed->id, $currentUser->id);
        $contentReactions = $contentReactionMapper->fetchCountLikeByFeedId($feed->id);
        */
        $contentReactionMapper = ContentReactionMapper::getInstance($this->adapter);
        $reactions = $contentReactionMapper->fetchCountByFeedId($feed->id);
        $reaction = $contentReactionMapper->fetchOneByFeedIdAndUserId($feed->id, $currentUser->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;
        }


        $timestamp = time();

        list($usec, $sec) = explode(' ', microtime());
        $seed = intval($sec + ((float) $usec * 100000));
        mt_srand($seed, MT_RAND_MT19937);
        $rand =  mt_rand();



        $password  = md5('user-' . $currentUser->uuid . '-feed-' . $feed->uuid . '-timestamp-' . $timestamp . '-rand-' . $rand . '-share-key-' . $currentUser->share_key);


        $share_params = [
            'type' => 'feed',
            'code' => $feed->uuid,
            'user' => $currentUser->uuid,
            'timestamp' => $timestamp,
            'rand' => $rand,
            'password' => $password,
        ];


        $share_increment_external_counter_url = $this->url()->fromRoute('share/increment-external-counter', $share_params, ['force_canonical' => true]);


        $share_external_url = $this->url()->fromRoute('shorter/generate', ['code' => $feed->uuid, 'type' => 'feed'], ['force_canonical' => true]);

        $item = [
            'feed_unique' => uniqid(),
            'feed_uuid' => $feed->uuid,
            'feed_my_reaction' => $reaction ? $reaction->reaction : '',
            'feed_delete_url' =>  '',
            'feed_content_type' => $feed->file_type ? $feed->file_type : '',
            'feed_reactions' => $reactions,
            'feed_reactions_url' =>  $this->url()->fromRoute('feed/reactions', ['id' => $feed->uuid], ['force_canonical' => true]),
            'feed_save_reaction_url' =>  $this->url()->fromRoute('feed/save-reaction', ['id' => $feed->uuid], ['force_canonical' => true]),
            'feed_highlighted' => $feed->id == $feedHighlighted ? 1 : 0,
            'feed_abuse_report_url' => $feed->user_id == $currentUser->id ? '' : $this->url()->fromRoute('helpers/abuse-report', ['type' => 'feed', 'id' => $feed->uuid], ['force_canonical' => true]),
            //'is_liked' => $contentReaction ? 1 : 0,
            //'like_url' => $this->url()->fromRoute('post/like', ['id' => $post->uuid]),
            //'unlike_url' => $this->url()->fromRoute('post/unlike', ['id' => $post->uuid]),

        ];
        
        $fastSurveyVote =  '';
        if($feed->file_type == Feed::FILE_TYPE_FAST_SURVEY) {
            
            $fastSurveyVoteMapper = FastSurveyVoteMapper::getInstance($this->adapter);
            $fastSurveyVote =  $fastSurveyVoteMapper->fetchOneByFastSurveyIdAndUserId($feed->fast_survey_id, $currentUser->id);
            
            
            
            $item['feed_save_reaction_url'] = '';
            $item['feed_delete_reaction_url'] =  '';
            $item['feed_share_url'] = '';
            $item['feed_share_external_url'] = '';
            $item['feed_increment_external_counter_url'] = '';
            
            $item['feed_vote_url'] = $fastSurveyVote ? '' : $this->url()->fromRoute('feed/vote',  ['id' => $feed->uuid], ['force_canonical' => true]);
            
        } else {
            $item['feed_save_reaction_url'] =  $this->url()->fromRoute('feed/save-reaction',  $params,  ['force_canonical' => true]);
            $item['feed_delete_reaction_url'] =  $this->url()->fromRoute('feed/delete-reaction',  $params,  ['force_canonical' => true]);
            $item['feed_share_url'] = $this->url()->fromRoute('feed/share',  $params,  ['force_canonical' => true]);
            $item['feed_share_external_url'] = $share_external_url;
            $item['feed_increment_external_counter_url'] = $share_increment_external_counter_url;
            $item['feed_vote_url'] = '';
        }
        

        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],  ['force_canonical' => true]);
                $item['owner_image'] = $storage->getCompanyImage($company);
                $item['owner_name'] = $company->name;
        
            } else if ($feed->type == Feed::TYPE_GROUP) {
                $groupMapper = GroupMapper::getInstance($this->adapter);
                $group = $groupMapper->fetchOne($feed->group_id);
                
               
                $item['owner_url'] = '';
                $item['owner_image'] = $storage->getGroupImage($group);
                $item['owner_name'] = $group->name;

                if ($group->user_id == $currentUser->id) {
                    $item['feed_delete_url'] = $this->url()->fromRoute('feed/delete',  $params,  ['force_canonical' => true]);
                }
            } else {
                $userMapper = UserMapper::getInstance($this->adapter);
                $user = $userMapper->fetchOne($feed->user_id);
                
                
                $item['owner_url'] = $this->url()->fromRoute('profile/view', ['id' => $user->uuid]);
                $item['owner_image'] = $storage->getUserImage($user); 
                $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,  ['force_canonical' => true]);
                }
            }
        } else {
            if ($feed->user_id == $currentUser->id) {
                $item['feed_delete_url'] = $this->url()->fromRoute('feed/delete',  $params,  ['force_canonical' => true]);
            }
        }

        $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/view', ['id' => $user->uuid],['force_canonical' => true]);
            $item['owner_image'] = $storage->getUserImage($user);
            $item['owner_name'] = $user->first_name . ' ' . $user->last_name;
        }

        if($feed->file_type == Feed::FILE_TYPE_FAST_SURVEY) {
            $fastSurveyMapper = FastSurveyMapper:: getInstance($this->adapter);
            $fastSurvey = $fastSurveyMapper->fetchOne($feed->fast_survey_id);
            
            $owner_description = [
                'question' => $fastSurvey->question,
                'number_of_answers' => $fastSurvey->number_of_answers,
                'answer1' => $fastSurvey->answer1,
                'answer2' => $fastSurvey->answer2,
                'answer3' => $fastSurvey->answer3,
                'answer4' => $fastSurvey->answer4,
                'answer5' => $fastSurvey->answer5,
                'result_type' => $fastSurvey->result_type,
                
            ];
            
            if($fastSurvey->expire_on > $now) {
                $owner_description['active'] = $fastSurveyVote ? 0 : 1;
                $owner_description['time_remaining'] =  Functions::getDateDiff($now, $fastSurvey->expire_on);
                
            } else {
   
                
                $owner_description['active'] = 0;
                $owner_description['time_remaining'] = 0;
            }
            
            if($fastSurvey->result_type == FastSurvey::RESULT_TYPE_PUBLIC && $fastSurveyVote) {
                $owner_description['votes1'] = $fastSurvey->votes1;
                $owner_description['votes2'] = $fastSurvey->votes2;
                $owner_description['votes3'] = $fastSurvey->votes3;
                $owner_description['votes4'] = $fastSurvey->votes4;
                $owner_description['votes5'] = $fastSurvey->votes5;
            }
            
            
            
            $item['owner_description'] =  $owner_description;
        } else {
            $item['owner_description'] = $feed->description;
        }
        
  
        
        $item['owner_feed_type'] = $feed->type;

        $item['owner_shared'] = $feed->total_shared;
        $item['owner_external_shared'] = $feed->total_external_shared;
        $item['owner_comments'] = $feed->total_comments;


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

        $path = $storage->getPathFeed();
        if ($feed->file_type == Storage::FILE_TYPE_IMAGE) {
            $item['owner_file_image'] = $storage->getGenericImage($path,  $feed->uuid, $feed->file_name); 
        }
        if ($feed->file_type == Storage::FILE_TYPE_DOCUMENT) {
            $item['owner_file_document'] = $storage->getGenericFile($path,  $feed->uuid, $feed->file_name); 
        }
        if ($feed->file_type == Storage::FILE_TYPE_VIDEO) {
            
            
            
            $item['owner_file_image_preview'] = $item['owner_file_image'] = $storage->getGenericImage($path,  $feed->uuid, $feed->file_image_preview); 
            $item['owner_file_video']  = $storage->getGenericFile($path,  $feed->uuid, $feed->file_name); 
        }

        if ($feed->posted_or_shared == Feed::SHARED) {
            $sharedFeed = $feedMapper->fetchOneAnyStatus($feed->shared_feed_id);

            $item['shared_description'] = $sharedFeed->description;
            $item['shared_time_elapse'] = Functions::timeAgo($sharedFeed->added_on, $now);

            if ($sharedFeed->file_type == Storage::FILE_TYPE_IMAGE) {
                $item['shared_file_image'] = $storage->getGenericImage($path, $sharedFeed->uuid, $sharedFeed->file_name);
            }
            if ($sharedFeed->file_type == Storage::FILE_TYPE_DOCUMENT) {
                $item['shared_file_document'] = $storage->getGenericFile($path, $sharedFeed->uuid, $sharedFeed->file_name);
            }
            if ($sharedFeed->file_type == Storage::FILE_TYPE_VIDEO) {
                $path = $storage->getPathFeed();
                $item['shared_file_image_preview'] = $storage->getGenericImage($path, $sharedFeed->uuid, $sharedFeed->file_image_preview);
                $item['shared_file_video'] = $storage->getGenericFile($path, $sharedFeed->uuid, $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'] = $storage->getCompanyImage($sharedCompany);
                $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'] = $storage->getGroupImage($sharedGroup);
                $item['shared_name'] = $sharedGroup->name;
            } else {
                $sharedUser = $userMapper->fetchOne($sharedFeed->user_id);
                
                $item['shared_url'] = $this->url()->fromRoute('profile/view', ['id' => $sharedUser->uuid]);
                $item['shared_image'] = $storage->getUserImage($sharedUser); 
                $item['shared_name'] = $sharedUser->first_name . ' ' . $sharedUser->last_name;
            }
        }

        

        if($feed->file_type == Feed::FILE_TYPE_FAST_SURVEY) {
            $item['comment_add_url'] = '';
            $item['comments'] = [];
        } else {
            
            $item['comment_add_url'] = $this->url()->fromRoute('feed/comment', ['id' => $feed->uuid],['force_canonical' => true]);
            $item['comments'] = [];

            $commentMapper = CommentMapper::getInstance($this->adapter);
            $records = $commentMapper->fetchAllPublishedByFeedId($feed->id , $user_blocked_ids, $abuse_report_comment_ids);
    
            $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
            $owner = $companyUserMapper->fetchOwnerByCompanyId($feed->company_id);
    
            $comments = [];
            foreach ($records as $record) {
                $user = $userMapper->fetchOne($record->user_id);
               
    
                if ($user->id == $currentUser->id) {
                    $link_delete = $this->url()->fromRoute('feed/comment/delete', ['id' => $feed->uuid, 'comment' => $record->uuid],['force_canonical' => true]);
                } else {
                    $link_delete = '';
                }

                array_push($comments , [
                    'unique' => uniqid(),
                    'user_url' => $this->url()->fromRoute('profile/view', ['id' => $user->uuid],['force_canonical' => true]),
                    'user_name' => $user->first_name . ' ' . $user->last_name,
                    'company' => $owner,
                    'user_image' => $storage->getUserImage($user),
                    'time_elapsed' => Functions::timeAgo($record->added_on, $now),
                    'comment' => $record->comment,
                    'link_abuse_report' => $user->id == $currentUser->id ? '' : $this->url()->fromRoute('helpers/abuse-report', ['type' => 'comment', 'id' => $record->uuid], ['force_canonical' => true]),
                    'link_delete' => $link_delete
                ]);
            }
            
            $item['comments'] = $comments;
        }
        

        return $item;
    }

    /**
     *
     * @param int $comment_id
     * @return array
     */
    private function renderComment($comment_id, $now)
    {
        $storage = Storage::getInstance($this->config, $this->adapter);
        
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $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);

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

            $item['unique'] = uniqid();
            $item['user_image'] = $storage->getUserImage($user);
            $item['user_url'] = $this->url()->fromRoute('profile', ['id' => $user->uuid]);
            $item['user_name'] = $user->first_name . ' ' . $user->last_name;
            $item['time_elapsed'] = Functions::timeAgo($record->added_on, $now);
            $item['comment'] = $record->comment;
            $item['link_abuse_report'] = $user->id == $currentUser ? '' : $this->url()->fromRoute('helpers/abuse-report', ['type' => 'comment', 'id' => $record->uuid], ['force_canonical' => true]);
            $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;
    }
    
    
    public function voteAction()
    {
        $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->fetchOneByUuidAndNetworkId($id, $currentUser->network_id);
            if (!$feed) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }
            
            
            if($feed->file_type != Feed::FILE_TYPE_FAST_SURVEY) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_FAST_SURVEY_FEED_IS_NOT_FAST_SURVEY' 
                ];
                return new JsonModel($response);
            }
       
            $fastSurveyMapper = FastSurveyMapper::getInstance($this->adapter);
            $fastSurvey = $fastSurveyMapper->fetchOne($feed->fast_survey_id);
            if(!$fastSurvey) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_FAST_SURVEY_NOT_FOUND'
                ];
                return new JsonModel($response);
            }
            
            $now = $fastSurveyMapper->getDatebaseNow();
            if($fastSurvey->expire_on <= $now) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_FAST_SURVEY_IS_EXPIRED'
                ];
                return new JsonModel($response);
            }
            
            
            if($fastSurvey->privacy == FastSurvey::PRIVACY_COMPANY) {
                
                $companyUserMapper = CompanyUserMapper::getInstance($this->adapter);
                $companyUser = $companyUserMapper->fetchOneByCompanyIdAndUserId($fastSurvey->company_id, $currentUser->id);
                if(!$companyUser || !in_array($companyUser->status, [CompanyUser::STATUS_ACCEPTED, CompanyUser::STATUS_ADMIN_WILL_ADD])) {
                    $response = [
                        'success' => false,
                        'data' => 'ERROR_FAST_SURVEY_UNAUTHORIZED'
                    ];
                    return new JsonModel($response);
                }
                
            }
            
            
            
            $vote = intval($this->params()->fromPost('vote', 0), 10);
            if($vote < 1 || $vote > 5 || $vote > $fastSurvey->number_of_answers) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_FAST_SURVEY_VOTE_IS_INVALID' 
                ];
                return new JsonModel($response);
            }
            
            $fastSurveyVoteMapper = FastSurveyVoteMapper::getInstance($this->adapter);
            $fastSurveyVote = $fastSurveyVoteMapper->fetchOneByFastSurveyIdAndUserId($fastSurvey->id, $currentUser->id);
            if($fastSurveyVote) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_FAST_SURVEY_VOTE_IS_ALREADY_FOUND'
                ];
                return new JsonModel($response);
            }
            
            $fastSurveyVote = new FastSurveyVote();
            $fastSurveyVote->fast_survey_id = $fastSurvey->id;
            $fastSurveyVote->user_id = $currentUser->id;
            $fastSurveyVote->vote = $vote;
            
            
            if ($fastSurveyVoteMapper->insert($fastSurveyVote)) {
                
                $response = [
                    'success'   => true,
                    'data'   => $this->renderFeed($feed->id, $now)
                ];
            } else {
                $response = [
                    'success' => false,
                    'data' => $fastSurveyVoteMapper->getError()
                ];
            }
            return new JsonModel($response);
        }
        
        $response = [
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ];
        return new JsonModel($response);
    }
}