Proyectos de Subversion LeadersLinked - Services

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

                if (!$post || $post->status != Post::STATUS_ACTIVE) {

                    return new JsonModel([

                        'success' => false,

                        'data' => 'ERROR_POST_NOT_AVAILABLE'

                    ]);

                }

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

            $type = '';

            if($post->file) {

                $filename = basename($post->file);

                $parts = explode(',', $filename);

                if(count($parts > 1)) {

                    $extension = $parts[ count($parts) -1 ];

                    if(in_array($extension, ['mov', 'webm','mp4','mpeg'] )) {

                        $type = 'video';

                    } else if(in_array($extension, ['jpg','jpeg','png'] )) {

                        $type = 'image';

                    } else if(in_array($extension, ['wav', 'mp3', 'pdf'] )) {

                        $type = 'audio';

                    }

                }

            }

                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,

                        'type' => $post->type,

                        'status' => $post->status,

                        'image' =>   $this->url()->fromRoute('storage',['type' => 'post', 'code' => $post->uuid, 'filename' => $post->image], ['force_canonical' => true]),

                        'file' => $post->file ? $this->url()->fromRoute('storage',['type' => 'post', 'code' => $post->uuid, 'filename' => $post->file], ['force_canonical' => true]) : '',

                        'type' => $type,

                        '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 {

            $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],['force_canonical' => true]);

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

    }

}