Proyectos de Subversion LeadersLinked - Antes de SPA

<?php

/**

 *

 * Controlador: Mis Perfiles

 *

 */

declare(strict_types=1);

namespace LeadersLinked\Controller;

use Laminas\Db\Adapter\AdapterInterface;

use Laminas\Cache\Storage\Adapter\AbstractAdapter;

use Laminas\Mvc\Controller\AbstractActionController;

use Laminas\Log\LoggerInterface;

use Laminas\View\Model\JsonModel;

use Laminas\Paginator\Paginator;

use Laminas\Paginator\Adapter\DbSelect;

use Laminas\View\Model\ViewModel;

use LeadersLinked\Library\Functions;

use LeadersLinked\Mapper\CompanyUserMapper;

use LeadersLinked\Model\Post;

use LeadersLinked\Mapper\PostMapper;

use LeadersLinked\Mapper\GroupMapper;

use LeadersLinked\Mapper\UserMapper;

use LeadersLinked\Mapper\CommentMapper;

use LeadersLinked\Mapper\ConnectionMapper;

use LeadersLinked\Mapper\CompanyFollowerMapper;

use LeadersLinked\Mapper\QueryMapper;

use LeadersLinked\Mapper\LikeMapper;

use LeadersLinked\Model\Like;

use LeadersLinked\Model\Comment;

use LeadersLinked\Model\CompanyUser;

use LeadersLinked\Mapper\CompanyMapper;

use LeadersLinked\Model\Company;

use LeadersLinked\Model\Group;

use LeadersLinked\Mapper\GroupMemberMapper;

use LeadersLinked\Model\GroupMember;

use LeadersLinked\Model\Notification;

use LeadersLinked\Mapper\NotificationMapper;

use LeadersLinked\Mapper\UserNotificationSettingMapper;

use LeadersLinked\Mapper\EmailTemplateMapper;

use LeadersLinked\Model\EmailTemplate;

use LeadersLinked\Library\QueueEmail;

use LeadersLinked\Mapper\UtilMapper;

use LeadersLinked\Form\Post\CommentForm;

class PostController extends AbstractActionController

{

    /**

     *

     * @var AdapterInterface

     */

    private $adapter;

    /**

     *

     * @var AbstractAdapter

     */

    private $cache;

    /**

     *

     * @var  LoggerInterface

     */

    private $logger;

    /**

     *

     * @var array

     */

    private $config;

    /**

     *

     * @param AdapterInterface $adapter

     * @param AbstractAdapter $cache

     * @param LoggerInterface $logger

     * @param array $config

     */

    public function __construct($adapter, $cache , $logger,  $config)

    {

        $this->adapter      = $adapter;

        $this->cache        = $cache;

        $this->logger       = $logger;

        $this->config       = $config;

    }

    /**

     *

     * 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) {

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

            $likeMapper = LikeMapper::getInstance($this->adapter);

            $like = $likeMapper->fetchOneByPostIdAndUserId($post->id, $currentUser->id);

            $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]),

                'is_liked' => $like ? 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);

            $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()) {

                $utilMapper = UtilMapper::getInstance($this->adapter);

                $now = $utilMapper->getDatebaseNow();

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

            }

            $likeMapper = LikeMapper::getInstance($this->adapter);

            $like = $likeMapper->fetchOneByPostIdAndUserId($post->id, $currentUser->id);

            if($like) {

                $response = [

                    'success' => false,

                    'data' => 'ERROR_DUPLICATE_ACTION'

                ];

                return new JsonModel($response);

            }

            $like = new Like();

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

            $like->post_id = $post->id;

            $like->relational = Like::RELATIONAL_POST;

            if($likeMapper->insert($like))

            {

                $likes = $likeMapper->fetchCountLikeByPostId($post->id);

                $response = [

                    'success' => true,

                    'data' => [

                        'likes' => $likes

                    ]

                ];

            } else {

                $response = [

                    'success' => false,

                    'data' => $likeMapper->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);

            }

            $likeMapper = LikeMapper::getInstance($this->adapter);

            $like = $likeMapper->fetchOneByPostIdAndUserId($post->id, $currentUser->id);

            if(!$like) {

                $response = [

                    'success' => false,

                    'data' => 'ERROR_DUPLICATE_ACTION'

                ];

                return new JsonModel($response);

            }

            if($likeMapper->deleteByPostIdAndUserId($post->id, $currentUser->id))

            {

                $likes = $likeMapper->fetchCountLikeByPostId($post->id);

                $response = [

                    'success' => true,

                    'data' => [

                        'likes' => $likes

                    ]

                ];

            } else {

                $response = [

                    'success' => false,

                    'data' => $likeMapper->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()) {

            $utilMapper = UtilMapper::getInstance($this->adapter);

            $now = $utilMapper->getDatebaseNow();

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

            $currentUser = $currentUserPlugin->getUser();

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

            $currentNetwork = $currentNetworkPlugin->getNetwork();

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

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

            $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', ['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;

    }

}