Proyectos de Subversion LeadersLinked - Antes de SPA

<?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\JsonModel;
use Laminas\View\Model\ViewModel;

use LeadersLinked\Library\Functions;
use LeadersLinked\Model\Post;
use LeadersLinked\Mapper\PostMapper;
use LeadersLinked\Mapper\UserMapper;
use LeadersLinked\Mapper\CommentMapper;
use LeadersLinked\Model\ContentReaction;
use LeadersLinked\Model\Comment;
use LeadersLinked\Form\Post\CommentForm;
use LeadersLinked\Mapper\ContentReactionMapper;



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

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

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

    public function viewAction()
    {
        $request = $this->getRequest();
        if ($request->isGet()) {
            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();


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

            $postMapper = PostMapper::getInstance($this->adapter);
            $post = $postMapper->fetchOneByUuid($id);

            $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) {
                if (!$post || $post->status != Post::STATUS_ACTIVE) {
                    return new JsonModel([
                        'success' => false,
                        'data' => 'ERROR_POST_NOT_AVAILABLE'
                    ]);
                }
                
            } else {
            
            
                if (!$post || $post->status != Post::STATUS_ACTIVE) {
                    $flashMessenger = $this->plugin('FlashMessenger');
    
                    if (!$id) {
                        $flashMessenger->addErrorMessage('ERROR_POST_NOT_AVAILABLE');
                        return $this->redirect()->toRoute('dashboard');
                    }
                }
            }

            $timestamp = time();
    
            list($usec, $sec) = explode(' ', microtime());
            $seed = intval($sec + ((float) $usec * 100000));
            mt_srand($seed, MT_RAND_MT19937);
            $rand =  mt_rand();
    
    
    
            $password  = md5('user-' . $currentUser->uuid . '-post-' . $post->uuid . '-timestamp-' . $timestamp . '-rand-' . $rand . '-share-key-' . $currentUser->share_key);
    
    
            $share_params = [
                'type' => 'post',
                'code' => $post->uuid,
                'user' => $currentUser->uuid,
                'timestamp' => $timestamp,
                'rand' => $rand,
                'password' => $password,
            ];
            $share_increment_external_counter_url = $this->url()->fromRoute('share/increment-external-counter', $share_params, ['force_canonical' => true]);
    
    
            $share_external_url = $this->url()->fromRoute('shorter/generate', ['code' => $post->uuid, 'type' => 'post'], ['force_canonical' => true]);
    
            //$contentReactionMapper = ContentReactionMapper::getInstance($this->adapter);
            //$contentReaction = $contentReactionMapper->fetchOneByPostIdAndUserId($post->id, $currentUser->id);
    
            $contentReactionMapper = ContentReactionMapper::getInstance($this->adapter);
            $reactions = $contentReactionMapper->fetchCountByPostId($post->id);
            $reaction = $contentReactionMapper->fetchOneByPostIdAndUserId($post->id, $currentUser->id);
                
            if ($isJson) {
                return new JsonModel([
                    'success' => true,
                    'data' => [
                        'post' => $post,
                        'id' => $post->id,
                        'uuid' => $post->uuid,
                        'title' => $post->title,
                        'description' => $post->description,
                        'url' => $post->url,
                        'date' => $post->date,
                        'status' => $post->status,
                        'image' => $post->image,
                        'file' => $post->file,
                        'added_on' => $post->added_on,
                        'share_external_url' =>  $share_external_url,
                        'total_share_external' => $post->total_external_shared,
                        'share_increment_external_counter_url' => $share_increment_external_counter_url,
                        'comments_url' => $this->url()->fromRoute('post/comments', ['id' => $post->uuid]),
                        'comments_add_url' => $this->url()->fromRoute('post/comments/add', ['id' => $post->uuid]),
                        'save_reaction_url' => $this->url()->fromRoute('post/save-reaction', ['id' => $post->uuid]),
                        'delete_reaction_url' =>  $this->url()->fromRoute('post/delete-reaction', ['id' => $post->uuid]),
                        'my_reaction' => $reaction ? $reaction->reaction : '',
                        'reactions' =>  $reactions,
                        //'is_liked' => $contentReaction ? 1 : 0,
                        //'like_url' => $this->url()->fromRoute('post/like', ['id' => $post->uuid]),
                        //'unlike_url' => $this->url()->fromRoute('post/unlike', ['id' => $post->uuid]),
                    
                    ]
                ]);
            } else {
                    
                
                $this->layout()->setTemplate('layout/layout.phtml');
                $viewModel = new ViewModel();
                $viewModel->setTemplate('leaders-linked/post/view.phtml');
                $viewModel->setVariables([
                    'post' => $post,
                    'id' => $post->id,
                    'uuid' => $post->uuid,
                    'title' => $post->title,
                    'description' => $post->description,
                    'url' => $post->url,
                    'date' => $post->date,
                    'status' => $post->status,
                    'image' => $post->image,
                    'file' => $post->file,
                    'added_on' => $post->added_on,
                    'share_external_url' =>  $share_external_url,
                    'total_share_external' => $post->total_external_shared,
                    'share_increment_external_counter_url' => $share_increment_external_counter_url,
                    'comments_url' => $this->url()->fromRoute('post/comments', ['id' => $post->uuid]),
                    'comments_add_url' => $this->url()->fromRoute('post/comments/add', ['id' => $post->uuid]),
                    'save_reaction_url' => $this->url()->fromRoute('post/save-reaction', ['id' => $post->uuid]),
                    'delete_reaction_url' =>  $this->url()->fromRoute('post/delete-reaction', ['id' => $post->uuid]),
                    'my_reaction' => $reaction ? $reaction->reaction : '',
                    'reactions' =>  $reactions,
                    //'is_liked' => $contentReaction ? 1 : 0,
                    //'like_url' => $this->url()->fromRoute('post/like', ['id' => $post->uuid]),
                    //'unlike_url' => $this->url()->fromRoute('post/unlike', ['id' => $post->uuid]),
    
                ]);
                return $viewModel;
            }
        } else {
            $response = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];

            return new JsonModel($response);
        }
    }

    public function commentsAddAction()
    {
        $id = $this->params()->fromRoute('id');

        $request = $this->getRequest();
        if ($request->isPost()) {



            $postMapper = PostMapper::getInstance($this->adapter);
            $now = $postMapper->getDatebaseNow();
            
            $post = $postMapper->fetchOneByUuid($id);
            if (!$post) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }

            $dataPost = $request->getPost()->toArray();
            $form = new CommentForm();
            $form->setData($dataPost);

            if ($form->isValid()) {


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

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



                $comment = new Comment();
                $comment->network_id = $currentUser->network_id;
                $comment->comment = $dataPost['comment'];
                $comment->user_id = $currentUser->id;
                $comment->post_id = $post->id;
                $comment->relational = Comment::RELATIONAL_POST;

                $commentMapper = CommentMapper::getInstance($this->adapter);
                if ($commentMapper->insert($comment)) {

                    $total_comments = $commentMapper->fetchCountCommentByPostId($comment->post_id);

                    $post->total_comments = $total_comments;
                    $postMapper->update($post);

                    $response = [
                        'success'   => true,
                        'data'   => $this->renderComment($comment->id, $now),
                        'total_comments' => $total_comments
                    ];

                    return new JsonModel($response);
                } else {

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

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

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

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

            return new JsonModel($response);
        }
    }



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

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

            $postMapper = PostMapper::getInstance($this->adapter);
            $post = $postMapper->fetchOneByUuidAndNetworkId($post_id, $currentUser->network_id);

            if ($post) {

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

                if ($comment && $comment->post_id == $post->id && $comment->user_id == $currentUser->id) {

                    $comment->status = Comment::STATUS_DELETED;

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

                        $total_comments = $commentMapper->fetchCountCommentByPostId($comment->post_id);


                        $postMapper = PostMapper::getInstance($this->adapter);
                        $post = $postMapper->fetchOne($comment->post_id);
                        $post->total_comments = $total_comments;
                        $postMapper->update($post);





                        $response = [
                            'success' => true,
                            'data' => 'LABEL_COMMENT_WAS_DELETED',
                            'total_comments' => $total_comments
                        ];
                    } else {
                        $response = [
                            'success' => false,
                            'data' => $commentMapper->getError()
                        ];
                    }
                } else {
                    $response = [
                        'success' => false,
                        'data' => 'ERROR_COMMENT_NOT_FOUND'
                    ];
                }
            } else {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_COMMENT_NOT_FOUND'
                ];
            }
        } else {
            $response = [
                'success' => false,
                'data' => 'ERROR_METHOD_NOT_ALLOWED'
            ];
        }

        return new JsonModel($response);
    }

    /*
    public function likeAction()
    {
        $id = $this->params()->fromRoute('id');

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


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

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

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

            $contentReaction = new Like();
            $contentReaction->user_id = $currentUser->id;
            $contentReaction->post_id = $post->id;
            $contentReaction->relational = Like::RELATIONAL_POST;

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

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

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

    public function unlikeAction()
    {
        $id = $this->params()->fromRoute('id');

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

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

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

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

            if ($contentReactionMapper->deleteByPostIdAndUserId($post->id, $currentUser->id)) {
                $contentReactions = $contentReactionMapper->fetchCountLikeByPostId($post->id);


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

        $response = [
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ];
        return new JsonModel($response);
    }*/
    
    public function saveReactionAction()
    {
        $id = $this->params()->fromRoute('id');
        $reaction  = $this->params()->fromPost('reaction');
        
        $request = $this->getRequest();
        if ($request->isPost()) {
            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();
            
            
            $postMapper = PostMapper::getInstance($this->adapter);
            $post = $postMapper->fetchOneByUuidAndNetworkId($id, $currentUser->network_id);
            if (!$post) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }
            
            $reactions = [
                ContentReaction::REACTION_RECOMMENDED, 
                ContentReaction::REACTION_SUPPORT,
                ContentReaction::REACTION_LOVE, 
                ContentReaction::REACTION_INTEREST, 
                ContentReaction::REACTION_FUN
                
            ];
            if(!in_array($reaction, $reactions)) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_REACTION_NOT_FOUND'
                ];
                return new JsonModel($response);
            }

            
            
            
            
            $contentReactionMapper = ContentReactionMapper::getInstance($this->adapter);
            $contentReaction = $contentReactionMapper->fetchOneByPostIdAndUserId($post->id, $currentUser->id);
            
            if ($contentReaction) {
                $contentReaction->reaction = $reaction;
                
                $result = $contentReactionMapper->update($contentReaction);
            } else {
                $contentReaction = new ContentReaction();
                $contentReaction->user_id = $currentUser->id;
                $contentReaction->post_id = $post->id;
                $contentReaction->relational = ContentReaction::RELATIONAL_POST;
                $contentReaction->reaction = $reaction;
                
                $result = $contentReactionMapper->insert($contentReaction);
            }
            

            
            if ($result) {
                
                $reactions = $contentReactionMapper->fetchCountByPostId($post->id);
                $response = [
                    'success' => true,
                    'data' => [
                        'reactions' => $reactions
                    ]
                ];
            } else {
                $response = [
                    'success' => false,
                    'data' => $contentReactionMapper->getError()
                ];
            }
            return new JsonModel($response);
        }
        
        $response = [
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ];
        return new JsonModel($response);
    }
    
    public function deleteReactionAction()
    {
        $id = $this->params()->fromRoute('id');
        
        $request = $this->getRequest();
        if ($request->isPost()) {
            $currentUserPlugin = $this->plugin('currentUserPlugin');
            $currentUser = $currentUserPlugin->getUser();
            
            $postMapper = PostMapper::getInstance($this->adapter);
            $post = $postMapper->fetchOneByUuidAndNetworkId($id, $currentUser->network_id);
            if (!$post) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_POST_NOT_FOUND'
                ];
                return new JsonModel($response);
            }
            
            $contentReactionMapper = ContentReactionMapper::getInstance($this->adapter);
            $contentReaction = $contentReactionMapper->fetchOneByPostIdAndUserId($post->id, $currentUser->id);
            
            if (!$contentReaction) {
                $response = [
                    'success' => false,
                    'data' => 'ERROR_DUPLICATE_ACTION'
                ];
                return new JsonModel($response);
            }
            
            if ($contentReactionMapper->deleteByPostIdAndUserId($post->id, $currentUser->id)) {
                $reactions = $contentReactionMapper->fetchCountByPostId($post->id);
                
                
                $response = [
                    'success' => true,
                    'data' => [
                        'reactions' => $reactions
                    ]
                ];
            } else {
                $response = [
                    'success' => false,
                    'data' => $contentReactionMapper->getError()
                ];
            }
            return new JsonModel($response);
        }
        
        $response = [
            'success' => false,
            'data' => 'ERROR_METHOD_NOT_ALLOWED'
        ];
        return new JsonModel($response);
    }

    public function commentsAction()
    {
        $id = $this->params()->fromRoute('id');

        $request = $this->getRequest();
        if ($request->isGet()) {
           
            

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

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


            $id = $this->params()->fromRoute('id');
            $postMapper = PostMapper::getInstance($this->adapter);
            $now = $postMapper->getDatebaseNow();
            
            $post = $postMapper->fetchOneByUuidAndNetworkId($id,  $currentNetwork->id);
            if (!$post) {
                $data = [
                    'success' => false,
                    'data' => 'ERROR_UNAUTHORIZED',
                ];

                return new JsonModel($data);
            }

            $commentMapper = CommentMapper::getInstance($this->adapter);
            $records = $commentMapper->fetchAllPublishedByPostId($post->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);
        }
    }



    /**
     *
     * @param int $comment_id
     * @return array
     */
    private function renderComment($comment_id, $now)
    {
        $item = [];

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

        $postMapper = PostMapper::getInstance($this->adapter);
        $post = $postMapper->fetchOne($record->post_id);

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

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

            $item['unique'] = uniqid();
            $item['user_image'] = $this->url()->fromRoute('storage', ['type' => 'user',  'code' => $user->uuid, 'filename' =>  $user->image]);
            $item['user_url'] = $this->url()->fromRoute('profile/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('post/comments/delete', ['id' => $post->uuid, 'comment' => $record->uuid]);
        }
        return $item;
    }
}