Proyectos de Subversion LeadersLinked - Antes de SPA

Rev

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

<?php
declare(strict_types=1);

namespace LeadersLinked\Controller;

use Laminas\Db\Adapter\AdapterInterface;

use Laminas\Mvc\Controller\AbstractActionController;
use Laminas\Log\LoggerInterface;
use Laminas\View\Model\ViewModel;
use Laminas\View\Model\JsonModel;
use LeadersLinked\Mapper\MyCoachCategoryMapper;

use LeadersLinked\Form\MyCoach\MyCoachQuestionForm;
use LeadersLinked\Library\MyCoachAccessControl;
use LeadersLinked\Form\MyCoach\MyCoachAnswerForm;
use LeadersLinked\Mapper\MyCoachQuestionMapper;
use LeadersLinked\Mapper\MyCoachQuestionCategoryMapper;
use LeadersLinked\Model\MyCoachQuestionCategory;
use LeadersLinked\Mapper\QueryMapper;
use LeadersLinked\Model\MyCoachQuestion;
use Laminas\Db\ResultSet\HydratingResultSet;
use Laminas\Paginator\Adapter\DbSelect;
use Laminas\Paginator\Paginator;
use LeadersLinked\Mapper\UserMapper;
use LeadersLinked\Hydrator\ObjectPropertyHydrator;
use LeadersLinked\Library\Functions;
use LeadersLinked\Mapper\MyCoachAnswerMapper;
use LeadersLinked\Mapper\CommentMapper;
use LeadersLinked\Model\MyCoachAnswer;
use LeadersLinked\Form\MyCoach\CommentForm;
use LeadersLinked\Model\Comment;
use LeadersLinked\Mapper\ContentReactionMapper;
use LeadersLinked\Model\ContentReaction;
use LeadersLinked\Mapper\MyCoachQuestionViewMapper;
use LeadersLinked\Model\MyCoachQuestionView;


class MyCoachController 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()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        if(!$currentUserPlugin->hasIdentity()) {
            $this->layout()->setTemplate('layout/layout');
            $viewModel = new ViewModel();
            $viewModel->setTemplate('leaders-linked/spa.phtml');
            return $viewModel;
        }
        
        
        
        $currentUser = $currentUserPlugin->getUser();
        
        
        

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

        $request = $this->getRequest();
        if ($request->isGet()) {
            
            $isJson = false;
            
            $headers  = $request->getHeaders();
            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');
                    }
                }
            }
            
            // $isJson = true;
            if ($isJson) {
                
                $myCoachAccesControl = MyCoachAccessControl::getInstance($this->adapter);
                $categories = $myCoachAccesControl->getCategoriesWithAccessToFormSelect($currentUser->id, $currentNetwork->id);
               
                return new JsonModel([
                    'success' => true,
                    'data' => [
                        'categories' => $categories,
                    ]
                ]);
                
            } else {
            
                $myCoachAccesControl = MyCoachAccessControl::getInstance($this->adapter);
                $categories = $myCoachAccesControl->getCategoriesWithAccessToFormSelect($currentUser->id, $currentNetwork->id);
                
                $formQuestion = new MyCoachQuestionForm($categories);
                $formAnswer = new MyCoachAnswerForm();
    
    
                $this->layout()->setTemplate('layout/layout');
                $viewModel = new ViewModel();
                $viewModel->setTemplate('leaders-linked/my-coach/index');
                $viewModel->setVariables([
                    'categories' => $categories,
                    'formQuestion' => $formQuestion,
                    'formAnswer' => $formAnswer,
                ]);
                return $viewModel;
            }

        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }
    
    public function questionsAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $currentNetworkPlugin = $this->plugin('currentNetworkPlugin');
        $currentNetwork = $currentNetworkPlugin->getNetwork();
        
        
        $request = $this->getRequest();
        if ($request->isGet()) {
            $userMapper                     = UserMapper::getInstance($this->adapter);
            $myCoachCategoryMapper          = MyCoachCategoryMapper::getInstance($this->adapter);
            $myCoachQuestionCategoryMapper  = MyCoachQuestionCategoryMapper::getInstance($this->adapter);
            $myCoachAccessControl           = MyCoachAccessControl::getInstance($this->adapter);
            
            $category_filter_id = Functions::sanitizeFilterString($this->params()->fromQuery('category_id'));
            $search = Functions::sanitizeFilterString($this->params()->fromQuery('search'));
            $page   = intval($this->params()->fromQuery('start', 1), 10);
            
            $order_field        = 'added_on';
            $order_direction    = 'asc';
            $records_x_page     = 12;
            

            if ($category_filter_id) {
                
                $message_error = '';
                if(!$myCoachAccessControl->hasAccessForCategory($currentUser->id, $category_filter_id, $currentNetwork->id, $message_error)) {
                    
                    return new JsonModel([
                        'success' => true,
                        'data' => $message_error,
                    ]);
                    
                }
                
                $categoryFilter = $myCoachCategoryMapper->fetchOneByUuid($category_filter_id);
                $category_ids = [$categoryFilter->id];
            } else {
                $category_ids = $myCoachAccessControl->getCategoryIdsWithAccess($currentUser->id, $currentNetwork->id);
            }
            
            $category_ids_with_edition = $myCoachAccessControl->getCategoryIdsWithEdition($currentUser->id);
            
            $queryMapper = QueryMapper::getInstance($this->adapter);
            
            $prototype = new MyCoachQuestion();
            $selectIn = $queryMapper->getSql()->select(MyCoachQuestionCategoryMapper::_TABLE);
            $selectIn->columns(['question_id']);
            $selectIn->where->in('category_id', $category_ids);
            
            
            
            $select = $queryMapper->getSql()->select(MyCoachQuestionMapper::_TABLE);
            $select->where->in('id', $selectIn);
            
            if($search) {
                $select->where->nest()
                -> like('title', '%' . $search . '%')->or->like('description', '%' . $search . '%')
                ->unnest();
            }
            $select->order($order_field . ' ' . $order_direction);
            
            //echo $select->getSqlString($this->adapter->platform);
            //exit;
            
            
            $users = [];
            $categories = [];
            //echo $select->getSqlString($this->adapter->platform); exit;
            
            $hydrator   = new ObjectPropertyHydrator();
            $resultset  = new HydratingResultSet($hydrator, $prototype);
            
            $adapter = new DbSelect($select, $queryMapper->getSql(), $resultset);
            $paginator = new Paginator($adapter);
            $paginator->setItemCountPerPage($records_x_page);
            $paginator->setCurrentPageNumber($page);
            
            
            $contentReactionMapper = ContentReactionMapper::getInstance($this->adapter);
            $commentMapper = CommentMapper::getInstance($this->adapter);
            $myCoachAnswerMapper = MyCoachAnswerMapper::getInstance($this->adapter);
            $myCoachQuestionViewMapper = MyCoachQuestionViewMapper::getInstance($this->adapter);
            
            $items = [];
            $records = $paginator->getCurrentItems();
            foreach ($records as $record)
            {
                $bags_categories = [];
                
                $questionCategories = $myCoachQuestionCategoryMapper->fetchAllByQuestionId($record->id);

                
 
                
                $allowEdit   = $myCoachAccessControl->hasAccessEditQuestion($currentUser->id, $record->id, $currentNetwork->id, $message_error);
                $allowDelete = $myCoachAccessControl->hasAccessDeleteQuestion($currentUser->id, $record->id, $currentNetwork->id, $message_error);
                foreach($questionCategories as $questionCategory)
                {
                    if(in_array($questionCategory->category_id, $category_ids_with_edition)) {
                        
                        $allowDelete = true;
                    }
                    
                    if (!isset($categories[$questionCategory->category_id])) {
                        $category = $myCoachCategoryMapper->fetchOne($questionCategory->category_id);
                        if ($category) {
                            $categories[$category->id] = $category->name;
                            
                        }
                    }
                    
                    array_push($bags_categories,['category' => $categories[ $questionCategory->category_id ] ]);
                }
                
                if(isset($users[$record->user_id])) {
                    $user = $users[ $record->user_id ];
                } else {
                    $user = $userMapper->fetchOne($record->user_id);
                    $users[ $record->user_id ] = $user;
                }
                
                
                $description = strip_tags($record->description);
                if (strlen($description) > 250) {
                    $description = substr($description, 0, 250) . '...';
                }
                
                
                $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->added_on);
                $added_on = $dt->format('d/m/Y H:i a');
                
                $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->updated_on);
                $updated_on = $dt->format('d/m/Y H:i a');
                
                $item = [
                    'uuid' => $record->uuid,
                    'user_name' => trim($user->first_name . ' ' . $user->last_name),
                    'user_image' => $this->url()->fromRoute('storage', ['type' => 'user', 'code' => $user->uuid, 'filename' => $user->image]),
                    'title' => $record->title,
                    'description' => $description,
                    'categories' => $bags_categories,
                    'views' => intval($myCoachQuestionViewMapper->fetchCountByQuestionId($record->id), 10),
                    'answers' =>  intval($myCoachAnswerMapper->fetchCountByMyCoachQuestionId($record->id), 10),
                    'reactions' => intval($contentReactionMapper->fetchCountByMyCoachQuestionId($record->id), 10),
                    'comments' =>  intval($commentMapper->fetchCountByMyCoachQuestionId($record->id), 10),
                    'added_on' => $added_on,
                    'updated_on' => $updated_on,
                    'link_add_comment' => $this->url()->fromRoute('my-coach/questions/comments/add', ['id' => $record->uuid]),
                    'link_view' => $this->url()->fromRoute('my-coach/questions/view', ['id' => $record->uuid]),
                    'link_edit' => $allowEdit ?  $this->url()->fromRoute('my-coach/questions/edit', ['id' => $record->uuid]) : '',
                    'link_delete' => $allowDelete ? $this->url()->fromRoute('my-coach/questions/delete', ['id' =>  $record->uuid]) : '',
                ];
                
                array_push($items, $item);
            }
            
            return new JsonModel([
                'success' => true,
                'data' => [
                    'items' => $items,
                    'total' => $paginator->getTotalItemCount(),
                    'page' => $paginator->getCurrentPageNumber(),
                    'total_pages' => $paginator->getPageRange()
                ]
            ]);
            
            
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }
    
    public function addQuestionAction()
    {
        $currentNetworkPlugin  = $this->plugin('currentNetworkPlugin');
        $currentNetwork        = $currentNetworkPlugin->getNetwork();
        
        $currentUserPlugin  = $this->plugin('currentUserPlugin');
        $currentUser        = $currentUserPlugin->getUser();
        
        $request            = $this->getRequest();
        
        if ($request->isPost()) {
            
            $dataPost = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());
            
            
            $myCoachAccessControl = MyCoachAccessControl::getInstance($this->adapter);
            $categories = $myCoachAccessControl->getCategoriesWithAccessToFormSelect($currentUser->id, $currentNetwork->id);
            
            $form = new MyCoachQuestionForm($categories);
            $form->setData($dataPost);
            
            if ($form->isValid()) {
                $dataPost = (array) $form->getData();
                
                $myCoachQuestion = new MyCoachQuestion();
                $myCoachQuestion->network_id    = $currentNetwork ->id;
                $myCoachQuestion->user_id       = $currentUser->id;
                $myCoachQuestion->title         = $dataPost['title'];
                $myCoachQuestion->description   = $dataPost['description'];
                
                
                $myCoachQuestionMapper = MyCoachQuestionMapper::getInstance($this->adapter);
                if ($myCoachQuestionMapper->insert($myCoachQuestion)) {
                    $myCoachCategoryMapper = MyCoachCategoryMapper::getInstance($this->adapter);
                    $myCoachQuestionCategoryMapper = MyCoachQuestionCategoryMapper::getInstance($this->adapter);
                    
                    $category_ids = $dataPost['category_id'];
                    foreach($category_ids as $category_id)
                    {
                        $myCoachCategory = $myCoachCategoryMapper->fetchOneByUuid($category_id);
                        if($myCoachCategory) {
                            $myCoachQuestionCategory = new MyCoachQuestionCategory();
                            $myCoachQuestionCategory->category_id = $myCoachCategory->id;
                            $myCoachQuestionCategory->question_id = $myCoachQuestion->id;
                            
                            $myCoachQuestionCategoryMapper->insert($myCoachQuestionCategory);
                        }
                    }
                    
                    
                    $this->logger->info('Se agrego la pregunta ' . $myCoachQuestion->title, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                    
                    $data = [
                        'success'   => true,
                        'data'   => 'LABEL_RECORD_ADDED'
                    ];
                } else {
                    $data = [
                        'success'   => false,
                        'data'      => $myCoachQuestionMapper->getError()
                    ];
                }
                
                return new JsonModel($data);
            } else {
                $messages = [];
                $form_messages = (array) $form->getMessages();
                foreach ($form_messages  as $fieldname => $field_messages)
                {
                    $messages[$fieldname] = array_values($field_messages);
                }
                
                return new JsonModel([
                    'success'   => false,
                    'data'   => $messages
                ]);
            }
        } else {
            $data = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
            
            return new JsonModel($data);
        }
        
        return new JsonModel($data);
    }
    
    
    
    public function deleteQuestionAction()
    {
        $currentNetworkPlugin  = $this->plugin('currentNetworkPlugin');
        $currentNetwork        = $currentNetworkPlugin->getNetwork();
        
        $currentUserPlugin  = $this->plugin('currentUserPlugin');
        $currentUser        = $currentUserPlugin->getUser();
        
        $request    = $this->getRequest();
        $id         = $this->params()->fromRoute('id');
        
        $message_error = '';
        $myCoachAccessControl = MyCoachAccessControl::getInstance($this->adapter);
        if(!$myCoachAccessControl->hasAccessDeleteQuestion($currentUser->id, $id, $currentNetwork->id, $message_error)) {
            return new JsonModel([
                'success'   => false,
                'data'   => $message_error
            ]);
        }
        
        
        $myCoachQuestionMapper = MyCoachQuestionMapper::getInstance($this->adapter);
        $myCoachQuestion = $myCoachQuestionMapper->fetchOneByUuid($id);

        
        if ($request->isPost()) {
            
            $myCoachQuestionCategoryMapper = MyCoachQuestionCategoryMapper::getInstance($this->adapter);
            $myCoachQuestionCategoryMapper->deleteAllByQuestionId($myCoachQuestion->id);
            
            $myCoachAnswerMapper = MyCoachAnswerMapper::getInstance($this->adapter);
            $myCoachAnswerMapper->deleteAllByQuestionId($myCoachQuestion->id);
            
            $result =  $myCoachQuestionMapper->delete($myCoachQuestion);
            if ($result) {
                $data = [
                    'success' => true,
                    'data' => 'LABEL_RECORD_DELETED'
                ];
            } else {
                
                $data = [
                    'success'   => false,
                    'data'      => $myCoachQuestionMapper->getError()
                ];
                
                return new JsonModel($data);
            }
        } else {
            $data = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
            
            return new JsonModel($data);
        }
        
        return new JsonModel($data);
    }
    
    
    public function editQuestionAction()
    {
        $currentNetworkPlugin  = $this->plugin('currentNetworkPlugin');
        $currentNetwork        = $currentNetworkPlugin->getNetwork();
        
        $currentUserPlugin  = $this->plugin('currentUserPlugin');
        $currentUser        = $currentUserPlugin->getUser();
        
        $request    = $this->getRequest();
        $id    = $this->params()->fromRoute('id');
        
        $message_error = '';
        $myCoachAccessControl = MyCoachAccessControl::getInstance($this->adapter);
        if(!$myCoachAccessControl->hasAccessEditQuestion($currentUser->id, $id, $currentNetwork->id, $message_error)) {
            return new JsonModel([
                'success'   => false,
                'data'   => $message_error
            ]);
        }
        
        
        $myCoachQuestionMapper = MyCoachQuestionMapper::getInstance($this->adapter);
        $myCoachQuestion = $myCoachQuestionMapper->fetchOneByUuid($id);
        
        
        if ($request->isGet()) {
            
            $category_ids = [];
            $myCoachCategoryMapper = MyCoachCategoryMapper::getInstance($this->adapter);
            
            $myCoachQuestionCategoryMapper = MyCoachQuestionCategoryMapper::getInstance($this->adapter);
            $records = $myCoachQuestionCategoryMapper->fetchAllByQuestionId($myCoachQuestion->id);
            foreach($records as $record)
            {
                $myCoachCategory = $myCoachCategoryMapper->fetchOne($record->category_id);
                if($myCoachCategory) {
                    array_push($category_ids,$myCoachCategory->uuid);
                }
            }
            
            
            
            $data = [
                'success' => true,
                'data' => [
                    'category_id' => $category_ids,
                    'title' => $myCoachQuestion->title,
                    'description' => $myCoachQuestion->description,
                ]
            ];
            
            return new JsonModel($data);
        } else if ($request->isPost()) {
            
            $categories = $myCoachAccessControl->getCategoriesWithAccessToFormSelect($myCoachQuestion->user_id, $currentNetwork->id);
            $dataPost = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());
            
            $form = new MyCoachQuestionForm($categories);
            $form->setData($dataPost);
            
            if ($form->isValid()) {
                $dataPost = (array) $form->getData();
                
                
                
                $myCoachQuestion->title = $dataPost['title'];
                $myCoachQuestion->description = $dataPost['description'];
                
                
                if ($myCoachQuestionMapper->update($myCoachQuestion)) {
                    
                    
                    $myCoachCategoryMapper = MyCoachCategoryMapper::getInstance($this->adapter);
                    
                    $myCoachQuestionCategoryMapper = MyCoachQuestionCategoryMapper::getInstance($this->adapter);
                    $myCoachQuestionCategoryMapper->deleteAllByQuestionId($myCoachQuestion->id);
                    
                    $category_ids = $dataPost['category_id'];
                    foreach($category_ids as $category_id)
                    {
                        $myCoachCategory = $myCoachCategoryMapper->fetchOneByUuid($category_id);
                        if($myCoachCategory) {
                            $myCoachQuestionCategory = new MyCoachQuestionCategory();
                            $myCoachQuestionCategory->category_id = $myCoachCategory->id;
                            $myCoachQuestionCategory->question_id = $myCoachQuestion->id;
                            
                            $myCoachQuestionCategoryMapper->insert($myCoachQuestionCategory);
                        }
                    }
                    
                    
                    $this->logger->info('Se edito la pregunta ' . $myCoachQuestion->title, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                    
                    $data = [
                        'success'   => true,
                        'data'   => 'LABEL_RECORD_UPDATED'
                    ];
                } else {
                    $data = [
                        'success'   => false,
                        'data'      => $myCoachQuestionMapper->getError()
                    ];
                }
                
                return new JsonModel($data);
            } else {
                $messages = [];
                $form_messages = (array) $form->getMessages();
                foreach ($form_messages  as $fieldname => $field_messages) {
                    
                    $messages[$fieldname] = array_values($field_messages);
                }
                
                return new JsonModel([
                    'success'   => false,
                    'data'   => $messages
                ]);
            }
        } else {
            $data = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
            
            return new JsonModel($data);
        }
        
        return new JsonModel($data);
    }
    
    
    public function viewQuestionAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $currentNetworkPlugin = $this->plugin('currentNetworkPlugin');
        $currentNetwork = $currentNetworkPlugin->getNetwork();
        
        $request    = $this->getRequest();
        $id    = $this->params()->fromRoute('id');
        
        $message_error = '';
        $myCoachAccessControl = MyCoachAccessControl::getInstance($this->adapter);
        if(!$myCoachAccessControl->hasAccessViewQuestion($currentUser->id, $id, $currentNetwork->id, $message_error)) {
            return new JsonModel([
                'success'   => false,
                'data'   => $message_error
            ]);
        }
        
        
        $myCoachQuestionMapper = MyCoachQuestionMapper::getInstance($this->adapter);
        $myCoachQuestion = $myCoachQuestionMapper->fetchOneByUuid($id);
        
        $contentReactionMapper = ContentReactionMapper::getInstance($this->adapter);
        $commentMapper = CommentMapper::getInstance($this->adapter);
        $myCoachQuestionViewMapper = MyCoachQuestionViewMapper::getInstance($this->adapter);
        $myCoachAnswerMapper = MyCoachAnswerMapper::getInstance($this->adapter);
        
        
        $request = $this->getRequest();
        if ($request->isGet()) {
            
            $categories = [];
            $users = [];
            
            
            
            $bags_categories = [];
            
            $myCoachQuestionViewMapper = MyCoachQuestionViewMapper::getInstance($this->adapter);
            $myCoachQuestionView = $myCoachQuestionViewMapper->fetchOneByQuestionIdAndUserId($myCoachQuestion->id, $currentUser->id);
            if(!$myCoachQuestionView) {
                $myCoachQuestionView = new MyCoachQuestionView();
                $myCoachQuestionView->question_id = $myCoachQuestion->id;
                $myCoachQuestionView->user_id = $currentUser->id;
                
                $myCoachQuestionViewMapper->insert($myCoachQuestionView);
                           
            }
            
            
            
            $myCoachCategoryMapper = MyCoachCategoryMapper::getInstance($this->adapter);
            $myCoachQuestionCategoryMapper = MyCoachQuestionCategoryMapper::getInstance($this->adapter);
            
            $questionCategories = $myCoachQuestionCategoryMapper->fetchAllByQuestionId($myCoachQuestion->id);
            foreach($questionCategories as $questionCategory)
            {
                
                if (!isset($categories[$questionCategory->category_id])) {
                    $category = $myCoachCategoryMapper->fetchOne($questionCategory->category_id);
                    if ($category) {
                        $categories[$category->id] = $category->name;
                    }
                }
                
                array_push($bags_categories,['category' => $categories[ $questionCategory->category_id ] ]);
            }
            
            $users = [];
            $userMapper = UserMapper::getInstance($this->adapter);
            if(isset($users[$myCoachQuestion->user_id])) {
                $user = $users[$myCoachQuestion->user_id];
            } else {
                $user = $userMapper->fetchOne( $myCoachQuestion->user_id );
                $users[ $myCoachQuestion->user_id ] = $user;
            }
            
            
            
            $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $myCoachQuestion->added_on);
            $added_on = $dt->format('d/m/Y H:i a');
            
            $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $myCoachQuestion->updated_on);
            $updated_on = $dt->format('d/m/Y H:i a');
            
            
            
            $allowDelete = $myCoachAccessControl->hasAccessDeleteQuestion($currentUser->id, $myCoachQuestion->id, $currentNetwork->id, $message_error);
            if($allowDelete) {
                $link_delete = $this->url()->fromRoute('my-coach/questions/delete', ['id' => $myCoachQuestion->uuid]);
            } else {
                $link_delete = '';
            }
            
            $allowAnswerAdd = $myCoachAccessControl->hasAccessAnswerQuestion($currentUser->id, $myCoachQuestion->id, $currentNetwork->id, $message_error);
            if ($allowAnswerAdd) {
                $link_answers_add = $this->url()->fromRoute('my-coach/questions/answers/add', ['id' => $myCoachQuestion->uuid]);
            } else {
                $link_answers_add = '';
            }
       
            

            $myCoachLastAnswer = $myCoachAnswerMapper->fetchOneLastAnswerByQuestionId($myCoachQuestion->id);
            
            if( $myCoachLastAnswer) {
                $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $myCoachLastAnswer->added_on);
                $last_answer_on = $dt->format('d/m/Y H:i a');
                
                
                
            } else {
                $last_answer_on = '';
            }
            

            return new JsonModel([
                'success' => true, 
                'data' => [
                    'uuid' => $myCoachQuestion->uuid,
                    'user_name' => trim($user->first_name . ' ' . $user->last_name),
                    'user_image' => $this->url()->fromRoute('storage', ['type' => 'user', 'code' => $user->uuid, 'filename' => $user->image]),
                    'title' => $myCoachQuestion->title,
                    'description' => $myCoachQuestion->description,
                    'categories' => $bags_categories,
                    'views' => intval($myCoachQuestionViewMapper->fetchCountByQuestionId($myCoachQuestion->id) , 10),
                    'answers' => intval($myCoachAnswerMapper->fetchCountByMyCoachQuestionId($myCoachQuestion->id) , 10),
                    'reactions' => intval($contentReactionMapper->fetchCountByMyCoachQuestionId($myCoachQuestion->id), 10),
                    'comments' => intval($commentMapper->fetchCountByMyCoachQuestionId($myCoachQuestion->id), 10),
                    'added_on' => $added_on,
                    'updated_on' => $updated_on,
                    'last_answer_on' => $last_answer_on,
                    'link_answers' => $this->url()->fromRoute('my-coach/questions/answers', ['id' => $myCoachQuestion->uuid]),
                    'link_answers_add' => $link_answers_add,
                    'link_delete' => $link_delete,
                ]
                
            ]);
            
            
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
        
        
        
        
        
    }
    
    /**
     *
     * {@inheritDoc}
     * @see \Laminas\Mvc\Controller\AbstractActionController::indexAction()
     */
    public function answersAction()
    {
        $currentUserPlugin = $this->plugin('currentUserPlugin');
        $currentUser = $currentUserPlugin->getUser();
        
        $currentNetworkPlugin = $this->plugin('currentNetworkPlugin');
        $currentNetwork = $currentNetworkPlugin->getNetwork();
        
        $request    = $this->getRequest();
        $id    = $this->params()->fromRoute('id');
        
        $message_error = '';
        $myCoachAccessControl = MyCoachAccessControl::getInstance($this->adapter);
        if(!$myCoachAccessControl->hasAccessViewQuestion($currentUser->id, $id, $currentNetwork->id, $message_error)) {
            return new JsonModel([
                'success'   => false,
                'data'   => $message_error
            ]);
        }
        
        
        
        $myCoachQuestionMapper = MyCoachQuestionMapper::getInstance($this->adapter);
        $myCoachQuestion = $myCoachQuestionMapper->fetchOneByUuid($id);
        
        $request = $this->getRequest();
        if ($request->isGet()) {
            
            
            $myCoachAnswerMapper = MyCoachAnswerMapper::getInstance($this->adapter);
            $now = $myCoachAnswerMapper->getDatebaseNow();
            
            $records = $myCoachAnswerMapper->fetchAllByQuestionId($myCoachQuestion->id);
            
            
            $items = [];
            
            foreach($records as $record)
            {
                $items[] = $this->renderAnswer($record->id, $currentUser->id, $now);
            }
            
            
            
            return new JsonModel([
                'success' => true,
                'data' => [
                    'items' => $items
                ]
            ]);
            
            
        } else {
            return new JsonModel([
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ]);
        }
    }
    
    public function deleteAnswerAction()
    {
        $currentNetworkPlugin  = $this->plugin('currentNetworkPlugin');
        $currentNetwork        = $currentNetworkPlugin->getNetwork();
        
        $currentUserPlugin  = $this->plugin('currentUserPlugin');
        $currentUser        = $currentUserPlugin->getUser();
        
        $request    = $this->getRequest();
        $answer     = $this->params()->fromRoute('answer');
        
        $message_error = '';
        $myCoachAccessControl = MyCoachAccessControl::getInstance($this->adapter);
        if(!$myCoachAccessControl->hasAccessEditOrDeleteAnswer($currentUser->id, $answer, $currentNetwork->id, $message_error)) {
            return new JsonModel([
                'success'   => false,
                'data'   => $message_error
            ]);
        }
        
        
        $myCoachAnswerMapper = MyCoachAnswerMapper::getInstance($this->adapter);
        $myCoachAnswer = $myCoachAnswerMapper->fetchOneByUuid($answer);
        
        if ($request->isPost()) {
            
            if($myCoachAnswerMapper->delete($myCoachAnswer)) {
                    
                $contentReactionMapper = ContentReactionMapper::getInstance($this->adapter);
                $commentMapper = CommentMapper::getInstance($this->adapter);
                
                
                $this->logger->info('Se borro la respuesta ' . $myCoachAnswer->text, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                    
                $data = [
                    'success'   => true,
                    'data'   => [
                        'total_comments' => intval($commentMapper->fetchCountByMyCoachQuestionId($myCoachAnswer->question_id), 10),
                        'total_answers' => intval($myCoachAnswerMapper->fetchCountByMyCoachQuestionId($myCoachAnswer->question_id), 10),
                        'total_reactions' => intval($contentReactionMapper->fetchCountByMyCoachQuestionId($myCoachAnswer->question_id), 10)
              
                    ]
                ];
            } else {
                $data = [
                    'success'   => false,
                    'data'      => $myCoachAnswerMapper->getError()
                ];
            }
        } else {
            $data = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
            
            
        }
        return new JsonModel($data);
        
        
    }
    
    
    public function editAnswerAction()
    {
        $currentNetworkPlugin  = $this->plugin('currentNetworkPlugin');
        $currentNetwork        = $currentNetworkPlugin->getNetwork();
        
        $currentUserPlugin  = $this->plugin('currentUserPlugin');
        $currentUser        = $currentUserPlugin->getUser();
        
        $request    = $this->getRequest();
        $answer     = $this->params()->fromRoute('answer');
        
        $message_error = '';
        $myCoachAccessControl = MyCoachAccessControl::getInstance($this->adapter);
        if(!$myCoachAccessControl->hasAccessEditOrDeleteAnswer($currentUser->id, $answer, $currentNetwork->id, $message_error)) {
            return new JsonModel([
                'success'   => false,
                'data'   => $message_error
            ]);
        }
        
        
        $myCoachAnswerMapper = MyCoachAnswerMapper::getInstance($this->adapter);
        $myCoachAnswer = $myCoachAnswerMapper->fetchOneByUuid($answer);
        
        if ($request->isPost()) {
            
            $dataPost = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());
            $form = new MyCoachAnswerForm();
            $form->setData($dataPost);
            
            if ($form->isValid()) {
                $myCoachAnswer->text        = $dataPost['description'];

                if($myCoachAnswerMapper->update($myCoachAnswer)) {
                    
                    $this->logger->info('Se edito la respuesta ' . $myCoachAnswer->text, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                    
                    $data = [
                        'success'   => true,
                        'data'   => [
                            'description' => $myCoachAnswer->text
                        ]
                    ];
                } else {
                    $data = [
                        'success'   => false,
                        'data'      => $myCoachAnswerMapper->getError()
                    ];
                }
                
                return new JsonModel($data);
            } else {
                $messages = [];
                $form_messages = (array) $form->getMessages();
                foreach ($form_messages  as $fieldname => $field_messages)
                {
                    $messages[$fieldname] = array_values($field_messages);
                }
                
                return new JsonModel([
                    'success'   => false,
                    'data'   => $messages
                ]);
            }
        } else  if ($request->isGet()) {
            return new JsonModel([
                'success'   => true,
                'data'   => [
                    'description' => $myCoachAnswer->text
                ]
            ]);
        } else {
            $data = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
            
            return new JsonModel($data);
        }
        
        
    }

    
    
    
    
    public function addAnswerAction()
    {
        $currentNetworkPlugin  = $this->plugin('currentNetworkPlugin');
        $currentNetwork        = $currentNetworkPlugin->getNetwork();
        
        $currentUserPlugin  = $this->plugin('currentUserPlugin');
        $currentUser        = $currentUserPlugin->getUser();
        
        $request    = $this->getRequest();
        $id    = $this->params()->fromRoute('id');
        
        $message_error = '';
        $myCoachAccessControl = MyCoachAccessControl::getInstance($this->adapter);
        if(!$myCoachAccessControl->hasAccessAnswerQuestion($currentUser->id, $id, $currentNetwork->id, $message_error)) {
            return new JsonModel([
                'success'   => false,
                'data'   => $message_error
            ]);
        }
        
        
        $myCoachQuestionMapper = MyCoachQuestionMapper::getInstance($this->adapter);
        $myCoachQuestion = $myCoachQuestionMapper->fetchOneByUuid($id);
        
        if ($request->isPost()) {
            
            $dataPost = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());
            $form = new MyCoachAnswerForm();
            $form->setData($dataPost);
            
            if ($form->isValid()) {
                
                $myCoachAnswer = new MyCoachAnswer();
                $myCoachAnswer->question_id = $myCoachQuestion->id;
                $myCoachAnswer->text        = $dataPost['description'];
                $myCoachAnswer->user_id     = $currentUser->id;

                
                $myCoachAnswerMapper = MyCoachAnswerMapper::getInstance($this->adapter);
                if($myCoachAnswerMapper->insert($myCoachAnswer)) {
                    $now = $myCoachAnswerMapper->getDatebaseNow();

                    $this->logger->info('Se agrego la respuesta ' . $myCoachAnswer->text, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
                    
                    $data = [
                        'success'   => true,
                        'data'   => [
                            'answers' => $myCoachAnswerMapper->fetchCountByMyCoachQuestionId($myCoachQuestion->id),
                            'item' => $this->renderAnswer($myCoachAnswer->id, $currentUser->id, $now)
                        ]
                    ];
                } else {
                    $data = [
                        'success'   => false,
                        'data'      => $myCoachQuestionMapper->getError()
                    ];
                }
                
                return new JsonModel($data);
            } else {
                $messages = [];
                $form_messages = (array) $form->getMessages();
                foreach ($form_messages  as $fieldname => $field_messages)
                {
                    $messages[$fieldname] = array_values($field_messages);
                }
                
                return new JsonModel([
                    'success'   => false,
                    'data'   => $messages
                ]);
            }
            
        } else {
            $data = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
            
            return new JsonModel($data);
        }
        
        
    }
    
    /*
    
    public function deleteAction()
    {
    $currentUserPlugin = $this->plugin('currentUserPlugin');
    $currentUser    = $currentUserPlugin->getUser();
    
    
    $request    = $this->getRequest();
    $id         = $this->params()->fromRoute('id');
    
    
    
    $myCoachQuestionMapper = MyCoachQuestionMapper::getInstance($this->adapter);
    $myCoachQuestion = $myCoachQuestionMapper->fetchOneByUuid($id);
    if (!$myCoachQuestion) {
    return new JsonModel([
    'success'   => false,
    'data'   => 'ERROR_RECORD_NOT_FOUND'
    ]);
    }
    
    $ok = false;
    if(!$myCoachQuestion->answers) {
    
    if($currentUser->id == $myCoachQuestion->user_id) {
    $ok = true;
    } else {
    $category_ids_with_edition = [];
    
    $myCoachCategoryUserMapper = MyCoachCategoryUserMapper::getInstance($this->adapter);
    $records = $myCoachCategoryUser = $myCoachCategoryUserMapper->fetchAllByUserId($currentUser->id);
    
    foreach($records as $record)
    {
    array_push($category_ids_with_edition, $record->user_id);
    }
    
    
    
    $myCoachQuestionCategoryMapper = MyCoachQuestionCategoryMapper::getInstance($this->adapter);
    $records = $myCoachQuestionCategoryMapper->fetchAllByQuestionId($myCoachQuestion->id);
    foreach($records as $record)
    {
    if (in_array($record->category_id, $category_ids_with_edition) && $myCoachCategoryUser->role == MyCoachCategoryUser::ROLE_EDITOR || $myCoachCategoryUser->role == MyCoachCategoryUser::ROLE_ADMINISTRATOR) {
    $ok = true;
    break;
    }
    }
    }
    }
    
    
    if (!$ok) {
    return new JsonModel([
    'success'   => false,
    'data'   => 'ERROR_KNOWLEDGE_AREA_YOU_DO_NOT_HAVE_PERMISSION'
    ]);
    }
    
    if ($request->isPost()) {
    
    $myCoachQuestionCategoryMapper = MyCoachQuestionCategoryMapper::getInstance($this->adapter);
    $myCoachQuestionCategoryMapper->deleteAllByQuestionId($myCoachQuestion->id);
    
    $result =  $myCoachQuestionMapper->delete($myCoachQuestion);
    if ($result) {
    $data = [
    'success' => true,
    'data' => 'LABEL_RECORD_DELETED'
    ];
    } else {
    
    $data = [
    'success'   => false,
    'data'      => $myCoachQuestionMapper->getError()
    ];
    
    return new JsonModel($data);
    }
    } else {
    $data = [
    'success' => false,
    'data' => 'ERROR_METHOD_NOT_ALLOWED'
    ];
    
    return new JsonModel($data);
    }
    
    return new JsonModel($data);
    }
    
    
    public function editAction()
    {
    $currentUserPlugin = $this->plugin('currentUserPlugin');
    $currentUser    = $currentUserPlugin->getUser();
    
    $request    = $this->getRequest();
    $id    = $this->params()->fromRoute('id');
    
    $myCoachQuestionMapper = MyCoachQuestionMapper::getInstance($this->adapter);
    $myCoachQuestion = $myCoachQuestionMapper->fetchOneByUuid($id);
    if (!$myCoachQuestion) {
    return new JsonModel([
    'success'   => false,
    'data'   => 'ERROR_RECORD_NOT_FOUND'
    ]);
    }
    
    $myCoachQuestionCategoryMapper = MyCoachQuestionCategoryMapper::getInstance($this->adapter);
    
    $ok = false;
    if(!$myCoachQuestion->answers) {
    
    if($currentUser->id == $myCoachQuestion->user_id) {
    $ok = true;
    } else {
    $category_ids_with_edition = [];
    
    $myCoachCategoryUserMapper = MyCoachCategoryUserMapper::getInstance($this->adapter);
    $records = $myCoachCategoryUser = $myCoachCategoryUserMapper->fetchAllByUserId($currentUser->id);
    
    foreach($records as $record)
    {
    array_push($category_ids_with_edition, $record->user_id);
    }
    
    
    $records = $myCoachQuestionCategoryMapper->fetchAllByQuestionId($myCoachQuestion->id);
    foreach($records as $record)
    {
    if (in_array($record->category_id, $category_ids_with_edition) && $myCoachCategoryUser->role == MyCoachCategoryUser::ROLE_EDITOR || $myCoachCategoryUser->role == MyCoachCategoryUser::ROLE_ADMINISTRATOR) {
    $ok = true;
    break;
    }
    }
    }
    }
    
    
    if (!$ok) {
    return new JsonModel([
    'success'   => false,
    'data'   => 'ERROR_KNOWLEDGE_AREA_YOU_DO_NOT_HAVE_PERMISSION'
    ]);
    }
    
    if (!$ok) {
    return new JsonModel([
    'success'   => false,
    'data'   => 'ERROR_KNOWLEDGE_AREA_YOU_DO_NOT_HAVE_PERMISSION'
    ]);
    }
    
    if ($request->isGet()) {
    
    
    $myCoachCategoryMapper = MyCoachCategoryMapper::getInstance($this->adapter);
    
    
    
    $category_ids = [];
    
    
    
    $records = $myCoachQuestionCategoryMapper->fetchAllByQuestionId($myCoachQuestion->id);
    foreach($records as $record)
    {
    $myCoachCategory = $myCoachCategoryMapper->fetchOne($record->category_id);
    if($myCoachCategory) {
    array_push($category_ids,$myCoachCategory->uuid);
    }
    }
    
    
    
    $data = [
    'success' => true,
    'data' => [
    'category_id' => $category_ids,
    'title' => $myCoachQuestion->title,
    'description' => $myCoachQuestion->description,
    ]
    ];
    
    return new JsonModel($data);
    } else if ($request->isPost()) {
    $category_with_edition_ids = [];
    $category_ids = [];
    
    
    $categories = [];
    
    
    $myCoachCategoryUserMapper = MyCoachCategoryUserMapper::getInstance($this->adapter);
    $records =  $myCoachCategoryUserMapper->fetchAllByUserId($currentUser->id);
    foreach ($records as $record) {
    if ($record->role == MyCoachCategoryUser::ROLE_ADMINISTRATOR || $record->role == MyCoachCategoryUser::ROLE_USER) {
    
    array_push($category_with_edition_ids, $record->category_id);
    }
    
    array_push($category_ids, $record->category_id);
    }
    
    $myCoachCategoryMapper = MyCoachCategoryMapper::getInstance($this->adapter);
    
    if ($category_ids) {
    $records =  $myCoachCategoryMapper->fetchAllByIds($category_ids);
    foreach ($records as $record) {
    if ($record->status == MyCoachCategory::STATUS_ACTIVE) {
    
    $categories[$record->id] = [
    'uuid' => $record->uuid,
    'name' => $record->name,
    ];
    }
    }
    }
    
    
    
    $categories = array_values($categories);
    usort($categories, function ($a, $b) {
    return $a['name'] <=> $b['name'];
    });
    
    $categories_question_available = [];
    foreach($categories as $cartegory)
    {
    $categories_question_available[ $cartegory['uuid'] ] = $cartegory['name'];
    }
    
    $dataPost = array_merge($request->getPost()->toArray(), $request->getFiles()->toArray());
    $form = new MyCoachQuestionForm($categories_question_available);
    $form->setData($dataPost);
    
    if ($form->isValid()) {
    $dataPost = (array) $form->getData();
    
    
    
    $myCoachQuestion->title = $dataPost['title'];
    $myCoachQuestion->description = $dataPost['description'];
    
    
    if ($myCoachQuestionMapper->update($myCoachQuestion)) {
    
    
    $myCoachCategoryMapper = MyCoachCategoryMapper::getInstance($this->adapter);
    
    $myCoachQuestionCategoryMapper = MyCoachQuestionCategoryMapper::getInstance($this->adapter);
    $myCoachQuestionCategoryMapper->deleteAllByQuestionId($myCoachQuestion->id);
    
    $category_ids = $dataPost['category_id'];
    foreach($category_ids as $category_id)
    {
    $myCoachCategory = $myCoachCategoryMapper->fetchOneByUuid($category_id);
    if($myCoachCategory) {
    $myCoachQuestionCategory = new MyCoachQuestionCategory();
    $myCoachQuestionCategory->category_id = $myCoachCategory->id;
    $myCoachQuestionCategory->question_id = $myCoachQuestion->id;
    
    $myCoachQuestionCategoryMapper->insert($myCoachQuestionCategory);
    }
    }
    
    
    $this->logger->info('Se edito la pregunta ' . $myCoachQuestion->title, ['user_id' => $currentUser->id, 'ip' => Functions::getUserIP()]);
    
    $data = [
    'success'   => true,
    'data'   => 'LABEL_RECORD_UPDATED'
    ];
    } else {
    $data = [
    'success'   => false,
    'data'      => $myCoachQuestionMapper->getError()
    ];
    }
    
    return new JsonModel($data);
    } else {
    $messages = [];
    $form_messages = (array) $form->getMessages();
    foreach ($form_messages  as $fieldname => $field_messages) {
    
    $messages[$fieldname] = array_values($field_messages);
    }
    
    return new JsonModel([
    'success'   => false,
    'data'   => $messages
    ]);
    }
    } else {
    $data = [
    'success' => false,
    'data' => 'ERROR_METHOD_NOT_ALLOWED'
    ];
    
    return new JsonModel($data);
    }
    
    return new JsonModel($data);
    }
    
    
    public function viewAction()
    {
    $currentUserPlugin = $this->plugin('currentUserPlugin');
    $currentUser = $currentUserPlugin->getUser();
    
    $currentNetworkPlugin = $this->plugin('currentNetworkPlugin');
    $currentNetwork = $currentNetworkPlugin->getNetwork();
    
    $request    = $this->getRequest();
    $id    = $this->params()->fromRoute('id');
    
    $myCoachQuestionMapper = MyCoachQuestionMapper::getInstance($this->adapter);
    $myCoachQuestion = $myCoachQuestionMapper->fetchOneByUuid($id);
    if (!$myCoachQuestion) {
    return new JsonModel([
    'success'   => false,
    'data'   => 'ERROR_RECORD_NOT_FOUND'
    ]);
    }
    
    
    $request = $this->getRequest();
    if ($request->isGet()) {
    
    
    
    $category_with_edition_ids = [];
    $category_ids = [];
    $categories = [];
    
    
    $myCoachCategoryUserMapper = MyCoachCategoryUserMapper::getInstance($this->adapter);
    $records =  $myCoachCategoryUserMapper->fetchAllByUserId($currentUser->id);
    foreach ($records as $record) {
    if ($record->role == MyCoachCategoryUser::ROLE_ADMINISTRATOR || $record->role == MyCoachCategoryUser::ROLE_USER) {
    
    array_push($category_with_edition_ids, $record->category_id);
    }
    
    array_push($category_ids, $record->category_id);
    }
    
    $myCoachCategoryMapper = MyCoachCategoryMapper::getInstance($this->adapter);
    
    
    
    if ($category_ids) {
    $records =  $myCoachCategoryMapper->fetchAllByIds($category_ids);
    foreach ($records as $record) {
    $categories[$record->id] = [
    'uuid' => $record->uuid,
    'name' => $record->name,
    ];
    }
    }
    
    $records =  $myCoachCategoryMapper->fetchAllPublicByNetworkId($currentNetwork->id);
    foreach ($records as $record) {
    if (!isset($categories[$record->id])) {
    
    $categories[$record->id] = [
    'uuid' => $record->uuid,
    'name' => $record->name,
    ];
    }
    }
    
    
    
    
    
    $categories = array_values($categories);
    usort($categories, function ($a, $b) {
    return $a['name'] <=> $b['name'];
    });
    
    
    $access = $myCoachQuestion->user_id == $currentUser->id;
    
    $allowDelete = false;
    $allowAnswer = false;
    
    $bags_categories = [];
    $myCoachQuestionCategoryMapper = MyCoachQuestionCategoryMapper::getInstance($this->adapter);
    
    $questionCategories = $myCoachQuestionCategoryMapper->fetchAllByQuestionId($myCoachQuestion->id);
    foreach($questionCategories as $questionCategory)
    {
    
    if(in_array($questionCategory->category_id, $categories)) {
    $access = true;
    }
    
    
    if(in_array($questionCategory->category_id, $category_with_edition_ids)) {
    
    $allowDelete = true;
    $allowAnswer = true;
    }
    
    if (!isset($categories[$questionCategory->category_id])) {
    $category = $myCoachCategoryMapper->fetchOne($questionCategory->category_id);
    if ($category) {
    $categories[$category->id] = [
    'uuid' =>  $category->uuid,
    'name' =>  $category->name,
    ];
    }
    }
    
    array_push($bags_categories,['category' => $categories[ $questionCategory->category_id ]['name'] ]);
    }
    
    $users = [];
    $userMapper = UserMapper::getInstance($this->adapter);
    if(isset($users[$myCoachQuestion->user_id])) {
    $user = $users[$myCoachQuestion->user_id];
    } else {
    $user = $userMapper->fetchOne( $myCoachQuestion->user_id );
    $users[ $myCoachQuestion->user_id ] = $user;
    }
    
    
    
    $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->added_on);
    $added_on = $dt->format('d/m/Y H:i a');
    
    $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->updated_on);
    $updated_on = $dt->format('d/m/Y H:i a');
    
    
    
    $data = [
    'user_name' => trim($user->first_name . ' ' . $user->last_name),
    'image' => $this->url()->fromRoute('storage', ['type' => 'user', 'code' => $user->uuid, 'filename' => $user->image]),
    'title' => $myCoachQuestion->title,
    'description' => $myCoachQuestion->description,
    'categories' => $bags_categories,
    'views' => $myCoachQuestion->views,
    'answers' => $myCoachQuestion->answers,
    'reactions' => $myCoachQuestion->reactions,
    'added_on' => $added_on,
    'updated_on' => $updated_on,
    'answers' => [],
    ];
    
    
    
    if($allowDelete || $myCoachQuestion->zuser_id == $currentUser->id) {
    $data['link_delete'] = $this->url()->fromRoute('my-coach/questions/delete', ['id' => $myCoachQuestion->uuid]);
    } else {
    $data['ink_delete'] = '';
    }
    
    
    if ($allowAnswer) {
    $data['link_answers'] = $this->url()->fromRoute('my-coach/questions/answers', ['id' => $myCoachQuestion->uuid]);
    } else {
    $data['link_answers'] = '';
    }
    
    $myCoachAnswerMapper = MyCoachAnswerMapper::getInstance($this->adapter);
    $records =  $myCoachAnswerMapper->fetchAllByQuestionId($myCoachQuestion->id);
    foreach($records as $record)
    {
    
    $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->added_on);
    $added_on = $dt->format('d/m/Y H:i a');
    
    $dt = \DateTime::createFromFormat('Y-m-d H:i:s', $record->updated_on);
    $updated_on = $dt->format('d/m/Y H:i a');
    
    if(isset($users[$record->user_id])) {
    $user = $users[$record->user_id];
    } else {
    $user = $userMapper->fetchOne( $record->user_id );
    $users[ $record->user_id ] = $user;
    }
    
    array_push($data['answers'], [
    'user_name' => trim($user->first_name . ' ' . $user->last_name),
    'image' => $this->url()->fromRoute('storage', ['type' => 'user', 'code' => $user->uuid, 'filename' => $user->image]),
    'text' => $record->text,
    'added_on' => $added_on,
    'updated_on' => $updated_on,
    'link_delete' => $allowAnswer ? $this->url()->fromRoute('my-coach/questions/answer/delete', ['code' => $myCoachQuestion->uuid, 'answer' => $record->uuid]) : '',
    ]);
    
    
    
    }
    
    
    
    
    return new JsonModel([
    'success' => true,
    'data' => $data
    ]);
    
    
    } else {
    return new JsonModel([
    'success' => false,
    'data' => 'ERROR_METHOD_NOT_ALLOWED'
    ]);
    }
    
    
    return new JsonModel($data);
    }
    */
    
    
    public function addCommentAction()
    {
        $currentNetworkPlugin  = $this->plugin('currentNetworkPlugin');
        $currentNetwork        = $currentNetworkPlugin->getNetwork();
        
        $currentUserPlugin  = $this->plugin('currentUserPlugin');
        $currentUser        = $currentUserPlugin->getUser();
        
        $request    = $this->getRequest();
        $id    = $this->params()->fromRoute('id');
        
        
        $request = $this->getRequest();
        if ($request->isPost()) {
            
            $message_error = '';
            $myCoachAccessControl = MyCoachAccessControl::getInstance($this->adapter);
            if(!$myCoachAccessControl->hasAccessViewAnswer($currentUser->id, $id, $currentNetwork->id, $message_error)) {
                return new JsonModel([
                    'success'   => false,
                    'data'   => $message_error
                ]);
            }
            
            $myCoachAnswerMapper = MyCoachAnswerMapper::getInstance($this->adapter);
            $myCoachAnswer = $myCoachAnswerMapper->fetchOneByUuid($id);
            
            $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->my_coach_answer_id = $myCoachAnswer->id;
                $comment->relational = Comment::RELATIONAL_MY_COACH;
                
                $commentMapper = CommentMapper::getInstance($this->adapter);
                if ($commentMapper->insert($comment)) {
                    $now = $commentMapper->getDatebaseNow();
                    
                    $response = [
                        'success'           => true,
                        'data'              => [
                            'item'  => $this->renderComment($comment->id, $now),
                            'total_comments_answer' => intval( $commentMapper->fetchCountByMyCoachAnswerId($myCoachAnswer->id), 10),
                            'total_comments_question' => intval( $commentMapper->fetchCountByMyCoachQuestionId($myCoachAnswer->question_id), 10),
                        ]    
                    ];
                    
                    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 deleteCommentAction()
    {
        $currentNetworkPlugin  = $this->plugin('currentNetworkPlugin');
        $currentNetwork        = $currentNetworkPlugin->getNetwork();
        
        $currentUserPlugin      = $this->plugin('currentUserPlugin');
        $currentUser            = $currentUserPlugin->getUser();
        
        $request                = $this->getRequest();
        $id                     = $this->params()->fromRoute('id');
        $comment                = $this->params()->fromRoute('comment');
        
        
        $request = $this->getRequest();
        if ($request->isPost()) {
            
            
            
            
            $message_error = '';
            $myCoachAccessControl = MyCoachAccessControl::getInstance($this->adapter);
            if(!$myCoachAccessControl->hasAccessViewAnswer($currentUser->id, $id, $currentNetwork->id, $message_error)) {
                return new JsonModel([
                    'success'   => false,
                    'data'   => $message_error
                ]);
            }
            
            $myCoachAnswerMapper = MyCoachAnswerMapper::getInstance($this->adapter);
            $myCoachAnswer = $myCoachAnswerMapper->fetchOneByUuid($id);
            
            $commentMapper = CommentMapper::getInstance($this->adapter);
            $comment = $commentMapper->fetchOneByUuid($comment);
            
            
            if ($comment && $comment->my_coach_answer_id == $myCoachAnswer->id && $comment->user_id == $currentUser->id) {
                
                $comment->status = Comment::STATUS_DELETED;
                
                if ($commentMapper->update($comment)) {

                    $response = [
                        'success' => true,
                        'data' => [
                            'message' => 'LABEL_COMMENT_WAS_DELETED',
                            'total_comments_answer' => intval( $commentMapper->fetchCountByMyCoachAnswerId($myCoachAnswer->id), 10),
                            'total_comments_question' => intval( $commentMapper->fetchCountByMyCoachQuestionId($myCoachAnswer->question_id), 10),
                        ]   
                    ];
                } else {
                    $response = [
                        'success' => false,
                        'data' => $commentMapper->getError()
                    ];
                    
                }
            } else {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_COMMENT_NOT_FOUND'
                ];
            }
        } else {
            $response = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
        }
        
        return new JsonModel($response);
    }
    
    public function reactionsAction()
    {
        return new JsonModel([
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ]);

    }
    
    
    
    public function saveReactionAction()
    {
        $currentNetworkPlugin  = $this->plugin('currentNetworkPlugin');
        $currentNetwork        = $currentNetworkPlugin->getNetwork();
        
        $currentUserPlugin  = $this->plugin('currentUserPlugin');
        $currentUser        = $currentUserPlugin->getUser();
        
        $request    = $this->getRequest();
        
        $id = $this->params()->fromRoute('id');
        $reaction  = $this->params()->fromPost('reaction');
        
        $request = $this->getRequest();
        if ($request->isPost()) {
            
            
            $message_error = '';
            $myCoachAccessControl = MyCoachAccessControl::getInstance($this->adapter);
            if(!$myCoachAccessControl->hasAccessViewAnswer($currentUser->id, $id, $currentNetwork->id, $message_error)) {
                return new JsonModel([
                    'success'   => false,
                    'data'   => $message_error
                ]);
            }
            
            $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);
            }
            
            $myCoachAnswerMapper = MyCoachAnswerMapper::getInstance($this->adapter);
            $myCoachAnswer = $myCoachAnswerMapper->fetchOneByUuid($id);
            
            $contentReactionMapper = ContentReactionMapper::getInstance($this->adapter);
            $contentReaction = $contentReactionMapper->fetchOneByMyCoachAnswerIdAndUserId($myCoachAnswer->id, $currentUser->id);
            
            if ($contentReaction) {
                $contentReaction->reaction = $reaction;
                
                $result = $contentReactionMapper->update($contentReaction);
            } else {
                $contentReaction = new ContentReaction();
                $contentReaction->user_id = $currentUser->id;
                $contentReaction->my_coach_answer_id = $myCoachAnswer->id;
                $contentReaction->relational = ContentReaction::RELATIONAL_MY_COACH;
                $contentReaction->reaction = $reaction;
                
                $result = $contentReactionMapper->insert($contentReaction);
            }
            
            
            
            if ($result) {
                
                $total_reactions_question = intval($contentReactionMapper->fetchCountByMyCoachQuestionId($myCoachAnswer->question_id), 10);
                $total_reactions_answer = intval($contentReactionMapper->fetchCountByMyCoachAnswerId($myCoachAnswer->id), 10);
                $response = [
                    'success' => true,
                    'data' => [
                        'reaction' => $reaction,
                        'total_reactions_question' => $total_reactions_question,
                        'total_reactions_answer' => $total_reactions_answer
                    ]
                ];
            } 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()
    {
        $currentNetworkPlugin  = $this->plugin('currentNetworkPlugin');
        $currentNetwork        = $currentNetworkPlugin->getNetwork();
        
        $currentUserPlugin  = $this->plugin('currentUserPlugin');
        $currentUser        = $currentUserPlugin->getUser();
        
        $request    = $this->getRequest();
        
        $id = $this->params()->fromRoute('id');
        
        $request = $this->getRequest();
        if ($request->isPost()) {
            
            $message_error = '';
            $myCoachAccessControl = MyCoachAccessControl::getInstance($this->adapter);
            if(!$myCoachAccessControl->hasAccessViewAnswer($currentUser->id, $id, $currentNetwork->id, $message_error)) {
                return new JsonModel([
                    'success'   => false,
                    'data'   => $message_error
                ]);
            }
            
            $myCoachAnswerMapper = MyCoachAnswerMapper::getInstance($this->adapter);
            $myCoachAnswer = $myCoachAnswerMapper->fetchOneByUuid($id);
            
            
            $contentReactionMapper = ContentReactionMapper::getInstance($this->adapter);
            $contentReaction = $contentReactionMapper->fetchOneByMyCoachAnswerIdAndUserId($myCoachAnswer->id, $currentUser->id);
            
            if ($contentReaction) {
                if ($contentReactionMapper->deleteByByMyCoachAnswerId($myCoachAnswer->id, $currentUser->id)) {
                    $total_reactions_question = intval($contentReactionMapper->fetchCountByMyCoachQuestionId($myCoachAnswer->question_id), 10);
                    $total_reactions_answer = intval($contentReactionMapper->fetchCountByMyCoachAnswerId($myCoachAnswer->id), 10);
                    
                    $response = [
                        'success' => true,
                        'data' => [
                            'total_reactions_question' => $total_reactions_question,
                            'total_reactions_answer' => $total_reactions_answer
                        ]
                    ];
                } else {
                    $response = [
                        'success' => false,
                        'data' => $contentReactionMapper->getError()
                    ];
                }
            } else {
                $total_reactions_question = $contentReactionMapper->fetchCountByMyCoachQuestionId($myCoachAnswer->question_id);
                $total_reactions_answer = $contentReactionMapper->fetchCountByMyCoachAnswerId($myCoachAnswer->id);
                
                $response = [
                    'success' => true,
                    'data' => [
                        'total_reactions_question' => $total_reactions_question,
                        'total_reactions_answer' => $total_reactions_answer
                    ]
                ];
                
                
            }
            
            
            
            return new JsonModel($response);
        }
        
        $response = [
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ];
        return new JsonModel($response);
    }
    
    public function commentsAction()
    {
        $currentNetworkPlugin  = $this->plugin('currentNetworkPlugin');
        $currentNetwork        = $currentNetworkPlugin->getNetwork();
        
        $currentUserPlugin  = $this->plugin('currentUserPlugin');
        $currentUser        = $currentUserPlugin->getUser();
        
        
        $id = $this->params()->fromRoute('id');
        
        $request = $this->getRequest();
        if ($request->isGet()) {
            $message_error = '';
            $myCoachAccessControl = MyCoachAccessControl::getInstance($this->adapter);
            if(!$myCoachAccessControl->hasAccessViewAnswer($currentUser->id, $id, $currentNetwork->id, $message_error)) {
                return new JsonModel([
                    'success'   => false,
                    'data'   => $message_error
                ]);
            }
            
            $myCoachAnswerMapper = MyCoachAnswerMapper::getInstance($this->adapter);
            $myCoachAnswer = $myCoachAnswerMapper->fetchOneByUuid($id);
            $now = $myCoachAnswerMapper->getDatebaseNow();
            
            $commentMapper = CommentMapper::getInstance($this->adapter);
            $records = $commentMapper->fetchAllPublishedByMyCoachAnswerId($myCoachAnswer->id);
            
            $comments = [];
            foreach ($records as $record) {
                $comment = $this->renderComment($record->id, $now);
                array_push($comments, $comment);
            }
            
            $response = [
                'success' => true,
                'data' => $comments
            ];
            
            return new JsonModel($response);
        } else {
            
            
            
            $response = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
            
            
            return new JsonModel($response);
        }
    }
    
    
    private function renderAnswer($answer_id, $current_user_id, $now)
    {
        $currentNetworkPlugin  = $this->plugin('currentNetworkPlugin');
        $currentNetwork        = $currentNetworkPlugin->getNetwork();
        $message_error = '';
        
        $myCoachAnswerMapper = MyCoachAnswerMapper::getInstance($this->adapter);
        $myCoachAnswer =  $myCoachAnswerMapper->fetchOne($answer_id);

        $myCoachQuestionMapper = MyCoachQuestionMapper::getInstance($this->adapter);
        $myCoachQuestion = $myCoachQuestionMapper->fetchOne($myCoachAnswer->question_id);
        
        
        $myCoachAccessControl = MyCoachAccessControl::getInstance($this->adapter);
        $hasAccessEditOrDeleteAnswer = $myCoachAccessControl->hasAccessEditOrDeleteAnswer($current_user_id, $answer_id, $currentNetwork->id, $message_error);
        if($hasAccessEditOrDeleteAnswer) {
            

            $link_edit = $this->url()->fromRoute('my-coach/questions/answers/edit',['id' => $myCoachQuestion->uuid, 'answer' => $myCoachAnswer->uuid]);
            $link_delete = $this->url()->fromRoute('my-coach/questions/answers/delete',['id' => $myCoachQuestion->uuid, 'answer' => $myCoachAnswer->uuid]);
            
        } else {
            $link_edit = '';
            $link_delete = '';
        }
        
        $userMapper = UserMapper::getInstance($this->adapter);
        $user = $userMapper->fetchOne($myCoachAnswer->user_id);
        
        $contentReactionMapper = ContentReactionMapper::getInstance($this->adapter);
        $contentReaction = $contentReactionMapper->fetchOneByMyCoachAnswerIdAndUserId($myCoachAnswer->id, $current_user_id);
        $total_reactions = intval($contentReactionMapper->fetchCountByMyCoachAnswerId($myCoachAnswer->id), 10);
        
       
        
        
        $comments = [];
        $commentMapper = CommentMapper::getInstance($this->adapter);
        $total_comments = $commentMapper->fetchCountByMyCoachAnswerId($myCoachAnswer->id);
        $records = $commentMapper->fetchAllPublishedByMyCoachAnswerId($myCoachAnswer->id);
        foreach($records as $record)
        {
            $comments[] = $this->renderComment($record->id, $now);
        }
        
        
        $item = [
            'unique' => uniqid(),
            'uuid' => $myCoachAnswer->uuid,
            'question_uuid' => $myCoachQuestion->uuid,
            'user_image' => $this->url()->fromRoute('storage', ['type' => 'user',  'code' => $user->uuid, 'filename' =>  $user->image]),
            'user_url' => $this->url()->fromRoute('profile/view', ['id' => $user->uuid]),
            'user_name' => $user->first_name . ' ' . $user->last_name,
            'time_elapsed' => Functions::timeAgo($myCoachAnswer->added_on, $now),
            'text' => $myCoachAnswer->text, 
            'reaction' => $contentReaction ? $contentReaction->reaction : '',  
            'total_comments' => $total_comments,
            'total_reactions' => $total_reactions,
            'comments' => $comments,
            'link_edit' => $link_edit,
            'link_delete' => $link_delete,
            'link_reaction_delete' => $this->url()->fromRoute('my-coach/questions/reaction/delete', ['id' => $myCoachAnswer->uuid]),
            'link_save_reaction' => $this->url()->fromRoute('my-coach/questions/reaction/save', ['id' => $myCoachAnswer->uuid]),
            'link_add_comment' => $this->url()->fromRoute('my-coach/questions/comments/add', ['id' => $myCoachAnswer->uuid]),
        ];

        return $item;
        
        
        
    }
    
    
    
    private function renderComment($comment_id, $now)
    {
        $item = [];
        
        $commentMapper = CommentMapper::getInstance($this->adapter);
        $record = $commentMapper->fetchOne($comment_id);
        
        $myCoachAnswerMapper = MyCoachAnswerMapper::getInstance($this->adapter);
        $myCoachAnswer = $myCoachAnswerMapper->fetchOne($record->my_coach_answer_id);
        
        
        if ($record) {
            $userMapper = UserMapper::getInstance($this->adapter);
            
            $user = $userMapper->fetchOne($record->user_id);
            
            $item['unique'] = uniqid();
            $item['answer_uuid'] = $myCoachAnswer->uuid;
            $item['user_image'] = $this->url()->fromRoute('storage', ['type' => 'user',  'code' => $user->uuid, 'filename' =>  $user->image]);
            $item['user_url'] = $this->url()->fromRoute('profile/view', ['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_delete'] = $this->url()->fromRoute('my-coach/questions/comments/delete', ['id' => $myCoachAnswer->uuid, 'comment' => $record->uuid]);
        }
        return $item;
    }

}