Proyectos de Subversion LeadersLinked - Backend

<?php

declare(strict_types=1);

namespace LeadersLinked\Controller;

use Laminas\Db\Adapter\AdapterInterface;

use Laminas\Cache\Storage\Adapter\AbstractAdapter;

use Laminas\Mvc\Controller\AbstractActionController;

use Laminas\Log\LoggerInterface;

use Laminas\View\Model\ViewModel;

use Laminas\View\Model\JsonModel;

use LeadersLinked\Mapper\CompanyMapper;

use LeadersLinked\Mapper\CompanyUserMapper;

use LeadersLinked\Form\CreateFeedForm;

use LeadersLinked\Form\CommentForm;

use LeadersLinked\Form\CommentAnswerForm;

use LeadersLinked\Model\Comment;

use LeadersLinked\Mapper\CommentMapper;

use LeadersLinked\Mapper\FeedMapper;

use LeadersLinked\Mapper\GroupMapper;

use LeadersLinked\Model\Feed;

use LeadersLinked\Mapper\QueryMapper;

use LeadersLinked\Hydrator\ObjectPropertyHydrator;

use LeadersLinked\Library\Image;

use LeadersLinked\Model\VideoConvert;

use LeadersLinked\Mapper\VideoConvertMapper;

use LeadersLinked\Mapper\LikeMapper;

use Laminas\Paginator\Adapter\DbSelect;

use Laminas\Paginator\Paginator;

use LeadersLinked\Mapper\UserMapper;

use LeadersLinked\Library\Functions;

use LeadersLinked\Model\Company;

use LeadersLinked\Model\UserType;

use Laminas\Authentication\AuthenticationService;

use Laminas\Authentication\Result as AuthResult;

use Laminas\Mvc\I18n\Translator;

use LeadersLinked\Mapper\MyTrainerQuestionsMapper;

use LeadersLinked\Mapper\FeedTopicMapper;

use LeadersLinked\Form\MyTrainerQuestionForm;

use LeadersLinked\Model\MyTrainerQuestions;

use LeadersLinked\Model\FeedTopic;

use LeadersLinked\Form\TopicForm;

class MyTrainerAnswerController 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;

    }

    public function indexAction()

    {

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

        $currentUser = $currentUserPlugin->getUser();

        $currentCompany = $currentUserPlugin->getCompany();

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

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

        $title  = $feedMapper->fetchOneByUuid($id);

        $request = $this->getRequest();

        if($request->isGet()) {

            $headers  = $request->getHeaders();

            $isJson = false;

            if($headers->has('Accept')) {

                $accept = $headers->get('Accept');

                $prioritized = $accept->getPrioritized();

                foreach($prioritized as $key => $value) {

                    $raw = trim($value->getRaw());

                    if(!$isJson) {

                        $isJson = strpos($raw, 'json');

                    }

                }

            }

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

            $this->layout()->setTemplate('layout/layout-backend');

            $viewModel = new ViewModel();

            $viewModel->setTemplate('leaders-linked/my-trainer-answer/index.phtml');

            $viewModel->setVariables([

                'form'      => $form,

                'id'        => $id,

                'title_title' => $title->title,

                'title_description' => $title->description,

            ]);

            return $viewModel ;

        } else {

            return new JsonModel([

                'success' => false,

                'data' => 'ERROR_METHOD_NOT_ALLOWED'

            ]);

        }

    }

    public function timelineAction(){

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

         $currentUser = $currentUserPlugin->getUser();

         $currentCompany = $currentUserPlugin->getCompany();

         $request = $this->getRequest();

         if($request->isGet()) {

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

                     if(!isset($feed_uuid)){

                    $data = [

                        'success'   => false,

                        'data'   => 'ERROR_INVALID_PARAMETER'

                    ];

                    return new JsonModel($data);

            }

            $items = [];

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

            $feed  = $feedMapper->fetchOneByUuid($feed_uuid);

            $feeds = $feedMapper->fetchAllByMytAnswer($feed->related_feed);

            if (!$feeds) {

                $data = [

                    'success' => false,

                    'data' => 'ERROR_RECORD_NOT_FOUND'

                ];

                      return new JsonModel($data);

            }

            $items = [];

            foreach($feeds as $solution)

            {

                $items = $this->renderFeed($solution->id);

            }

               $response = [

                    'success' => true,

                    'data' => [

                        'items' =>$items,

                        'feed_title'=>$feed->title,

                        'topic_title'=>$feed->description

                    ]

                ];

                      return new JsonModel($response);

        }

    }

    public function feedAction() {

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

        $currentUser = $currentUserPlugin->getUser();

        $currentCompany = $currentUserPlugin->getCompany();

        $request = $this->getRequest();

        if($request->isGet()) {

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

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

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

            $myt  = $feedMapper->fetchOneByUuid($myt_id);

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

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

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

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

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

            $select->where->equalTo('related_feed', $myt->id);

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

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

    }

    public function addAction() {

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

        $currentCompany     = $currentUserPlugin->getCompany();

        $currentUser        = $currentUserPlugin->getUser();

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

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

        $question = $questionsMapper->fetchOneByUuid($id);

        $request    = $this->getRequest();

        try{

        if($request->isPost()) {

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

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

            $categoriesId = $dataPost['category_id'] ?? [];

            $dataPost['category_id'] = null;

            $form->setData($dataPost);

            if($form->isValid()) {

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

                $hydrator = new ObjectPropertyHydrator();

                $feed = new Feed();

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

                $feed->user_id = $currentUser->id;

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

                $feed->user_id          = $currentUser->id;

                $feed->type             = Feed::TYPE_MYT_ANSWER;

                $feed->posted_or_shared = Feed::POSTED;

                $feed->shared_with      = Feed::SHARE_WITH_PUBLIC;

                $feed->related_feed = $question->id;

                $feed->total_comments   = 0;

                $feed->total_shared     = 0;

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

                $file_type = '';

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

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

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

                    $mime_type = mime_content_type($feed_tmp_filename);

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

                        $file_type = Feed::FILE_TYPE_IMAGE;

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

                        $file_type = Feed::FILE_TYPE_VIDEO;

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

                        $file_type = Feed::FILE_TYPE_DOCUMENT;

                    }

                }

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

                if($feedMapper->insert($feed)) {

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

                    $category = new FeedTopic();

                    $feedMapper->update($feed);

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

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

                            try {

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

                                if(!file_exists($target_path)) {

                                    mkdir($target_path, 0755);

                                }

                                $full_filename = $target_path  . DIRECTORY_SEPARATOR .$feed_filename;

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

                                if($result) {

                                    $feed->file_type = $file_type;

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

                                    $feedMapper->update($feed);

                                } else {

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

                                }

                            } catch(\Throwable $e) {

                                error_log($e->getTraceAsString());

                            }

                        }

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

                            try {

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

                                if(!file_exists($target_path)) {

                                    mkdir($target_path, 0755);

                                }

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

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

                                $crop_to_dimensions = false;

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

                                    $feed->file_type = $file_type;

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

                                    $feedMapper->update($feed);

                                }

                            } catch(\Throwable $e) {

                                error_log($e->getTraceAsString());

                            }

                        }

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

                            try {

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

                                if(!file_exists($target_path)) {

                                    mkdir($target_path, 0755);

                                }

                                $full_filename = $target_path  . DIRECTORY_SEPARATOR . $feed_filename;

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

                                if($result) {

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

                                    $getFromSecound = 2;

                                    //extracción del cover

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

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

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

                                    exec($cmd);

                                    $feed->file_type = $file_type;

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

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

                                    $feedMapper->update($feed);

                                    $videoConvert = new VideoConvert();

                                    $videoConvert->filename = $full_filename;

                                    $videoConvert->type = VideoConvert::TYPE_FEED;

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

                                    $videoConvertMapper->insert($videoConvert);

                                } else {

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

                                }

                            } catch(\Throwable $e) {

                                error_log($e->getTraceAsString());

                            }

                        }

                        $response = [

                            'success'   => true,

                            'data'   => 'success'

                        ];

                } else {

                    $messages = [];

                    $form_messages = (array) $form->getMessages();

                    foreach($form_messages  as $fieldname => $field_messages)

                    {

                        $messages[$fieldname] = array_values($field_messages);

                    }

                }

            } else {

                $response = [

                    'success' => false,

                    'data' => 'ERROR_METHOD_NOT_ALLOWED'

                ];

            }

            return new JsonModel($response);

        }

    } catch (\Throwable $e) {

        $e->getMessage();

        return new JsonModel([

            'success' => false,

            'data' => $e

        ]);

    }

    }

     /**

     *

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

    }

    private function renderFeed($id){

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

        if($sandbox) {

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

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

        } else {

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

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

        }

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

        $currentUser = $currentUserPlugin->getUser();

        $currentCompany = $currentUserPlugin->getCompany();

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

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

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

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

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

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

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

        $params = [

            'id' => $feed->uuid,

        ];

        $item = [

            'feed_unique' => uniqid(),

            'feed_uuid' => $feed->uuid,

            'feed_description' => $feed->description,

            'feed_delete_url' =>  $this->url()->fromRoute('my-trainer/question/answer/delete', $params),

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

            'feed_priority'=> $feed->priority,

        ];

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

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

        $item['feed_delete_url'] = $this->url()->fromRoute('my-trainer/question/answer/delete',  $params);

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

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

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

        $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->file_type == Feed::FILE_TYPE_MEETING) {

            $dt = \DateTime::createFromFormat('Y-m-d', $feed->date);

            $dt2 = \DateTime::createFromFormat('H:i:s', $feed->time);

            $item['owner_meeting'] =  true;

            $item['owner_meeting_date'] =  $dt->format('d/m/Y');

            $item['owner_meeting_time'] =  $dt2->format('h:i a');

            $item['owner_meeting_link_type'] =  $feed->link_type;

            $item['owner_meeting_link_name'] =  $feed->link_name;

        }

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

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

        $comments = [];

        $comment_count=0;

        foreach($records as $record)

        {

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

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

            $comment = [];

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

            $comment_count++;

            $comment['comment_index']=$comment_count;

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

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

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

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

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

            } else {

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

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

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

            }

            $comment['link_delete'] = $this->url()->fromRoute('my-trainer/question/answer/comments/delete',['id' => $feed->uuid, 'comment' => $record->uuid ]);

            $comment['link_answer_add'] = $this->url()->fromRoute('my-trainer/question/answer/comments/answer',['id' => $feed->uuid, 'comment' => $record->uuid ]);

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

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

            $records2 = $commentMapper->fetchAllPublishedByCommentId($record->id);

            $answers = [];

            $contador=0;

            foreach($records2 as $record2)

            {

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

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

                $answer = [];

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

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

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

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

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

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

                } else {

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

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

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

                }

                    $answer['link_delete'] = $this->url()->fromRoute('my-trainer/question/answer/comments/delete',['id' => $feed->uuid, 'comment' => $record2->uuid ]);

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

                $answer['comment'] = $record2->comment;

                $records2 = $commentMapper->fetchAllPublishedByCommentId($record2->id);

                $contador++;

                array_push($answers, $answer);

            }

            $comment['number_answers']=$contador;

            $comment['answers'] = $answers;

            array_push($comments, $comment);

        }

        $item['comment_add_url'] = $this->url()->fromRoute('my-trainer/question/answer/comments', ['id' => $feed->uuid]);

            $item['comments'] = $comments;

        return $item;

    }

    public function commentAction()

    {

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

        $currentUser = $currentUserPlugin->getUser();

        $currentCompany = $currentUserPlugin->getCompany();

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

        $request = $this->getRequest();

        if($request->isPost()) {

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

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

            if(!$feed) {

                $response = [

                    'success' => false,

                    'data' => 'ERROR_POST_NOT_FOUND'

                ];

                return new JsonModel($response);

            }

            if($feed->company_id != $currentCompany->id) {

                $response = [

                    'success' => false,

                    'data' => 'ERROR_UNAUTHORIZED'

                ];

                return new JsonModel($response);

            }

            $dataPost = $request->getPost()->toArray();

            $form = new CommentForm();

            $form->setData($dataPost);

            if($form->isValid()) {

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

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

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

                $comment = new Comment();

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

                $comment->feed_id = $feed->id;

                $comment->user_id = $currentCompany->id;

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

                if($commentMapper->insert($comment)) {

                    $total_comments = $commentMapper->fetchCountCommentByFeedId($comment->feed_id);

                    $feed->total_comments = $total_comments;

                    $feedMapper->update($feed);

                    $response = [

                        'success'   => true,

                        'data'   => $this->renderComment($comment->id),

                        'total_comments' => $total_comments

                    ];

                    return new JsonModel($response);

                } else {

                    $response = [

                        'success'   => false,

                        'data'   => $commentMapper->getError()

                    ];

                    return new JsonModel($response);

                }

            } else {

                $message = '';;

                $form_messages = (array) $form->getMessages();

                foreach($form_messages  as $fieldname => $field_messages)

                {

                    foreach( $field_messages as $key => $value)

                    {

                        $message = $value;

                    }

                }

                $response = [

                    'success'   => false,

                    'data'   => $message

                ];

                return new JsonModel($response);

            }

        } else {

            $response = [

                'success' => false,

                'data' => 'ERROR_METHOD_NOT_ALLOWED'

            ];

            return new JsonModel($response);

        }

    }

    public function answerAction()

    {

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

        $currentUser = $currentUserPlugin->getUser();

        $currentCompany = $currentUserPlugin->getCompany();

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

        $comment_uuid = $this->params()->fromRoute('comment');

        $request = $this->getRequest();

        if($request->isPost()) {

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

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

            if(!$feed) {

                $response = [

                    'success' => false,

                    'data' => 'ERROR_POST_NOT_FOUND'

                ];

                return new JsonModel($response);

            }

            if($feed->company_id != $currentCompany->id) {

                $response = [

                    'success' => false,

                    'data' => 'ERROR_UNAUTHORIZED'

                ];

                return new JsonModel($response);

            }

            $dataPost = $request->getPost()->toArray();

            $form = new CommentAnswerForm();

            $form->setData($dataPost);

            if($form->isValid()) {

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

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

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

                $answer = new Comment();

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

                $answer->feed_id = $feed->id;

                $answer->user_id = $owner->user_id;

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

                $comment=$commentMapper->fetchOneByUuid($comment_uuid);

                $answer->parent_id = $comment->id;

                if($commentMapper->insert($answer)) {

                    $total_comments = $commentMapper->fetchCountCommentByFeedId($comment->feed_id);

                    $feed->total_comments = $total_comments;

                    $feedMapper->update($feed);

                    $response = [

                        'success'   => true,

                        'data'   => $this->renderComment($answer->id),

                        'total_comments' => $total_comments

                    ];

                    return new JsonModel($response);

                } else {

                    $response = [

                        'success'   => false,

                        'data'   => $commentMapper->getError()

                    ];

                    return new JsonModel($response);

                }

            } else {

                $message = '';;

                $form_messages = (array) $form->getMessages();

                foreach($form_messages  as $fieldname => $field_messages)

                {

                    foreach( $field_messages as $key => $value)

                    {

                        $message = $value;

                    }

                }

                $response = [

                    'success'   => false,

                    'data'   => $message

                ];

                return new JsonModel($response);

            }

        } else {

            $response = [

                'success' => false,

                'data' => 'ERROR_METHOD_NOT_ALLOWED'

            ];

            return new JsonModel($response);

        }

    }

    public function commentDeleteAction()

    {

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

        $currentUser = $currentUserPlugin->getUser();

        $currentCompany = $currentUserPlugin->getCompany();

        $request = $this->getRequest();

        if($request->isPost()) {

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

            $currentUser = $currentUserPlugin->getUser();

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

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

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

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

            if(!$feed) {

                $response = [

                    'success' => false,

                    'data' => 'ERROR_POST_NOT_FOUND'

                ];

                return new JsonModel($response);

            }

            if($feed->company_id != $currentCompany->id) {

                $response = [

                    'success' => false,

                    'data' => 'ERROR_UNAUTHORIZED'

                ];

                return new JsonModel($response);

            }

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

            $comment = $commentMapper->fetchOneByUuid($comment);

            if($comment && $comment->feed_id == $feed->id) {

                $comment->status = Comment::STATUS_DELETED;

                if($commentMapper->update($comment)) {

                    $total_comments = $commentMapper->fetchCountCommentByFeedId($comment->feed_id);

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

                    $feed->total_comments = $total_comments;

                    $feedMapper->update($feed);

                    $response = [

                        'success' => true,

                        'data' => [

                            'message' => 'LABEL_COMMENT_WAS_DELETED',

                            'total_comments' => $total_comments

                        ]

                   ];

                } else {

                    $response = [

                        'success' => false,

                        'data' => $commentMapper->getError()

                    ];

                }

            } else {

                $response = [

                    'success' => false,

                    'data' => 'ERROR_COMMENT_NOT_FOUND'

                ];

            }

        } else {

            $response = [

                'success' => false,

                'data' => 'ERROR_METHOD_NOT_ALLOWED'

            ];

        }

        return new JsonModel($response);

    }

    private function renderComment($comment_id)

    {

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

        $currentUser = $currentUserPlugin->getUser();

        $currentCompany = $currentUserPlugin->getCompany();

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

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

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

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

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

        if($sandbox) {

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

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

        } else {

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

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

        }

        $item = [];

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

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

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

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

        if($record) {

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

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

            $item = [];

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

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

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

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

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

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

            } else {

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

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

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

            }

            $item['link_answer_add'] = $this->url()->fromRoute('my-trainer/question/answer/comments/answer',['id' => $feed->uuid, 'comment' => $record->uuid ]);

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

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

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

        }

        return $item;

    }

    public function deleteAction()

    {

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

        $currentUser = $currentUserPlugin->getUser();

        $currentCompany = $currentUserPlugin->getCompany();

        $request = $this->getRequest();

        if($request->isPost()) {

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

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

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

            if(!$feed) {

                $response = [

                    'success' => false,

                    'data' => 'ERROR_POST_NOT_FOUND'

                ];

                return new JsonModel($response);

            }