colleague / study-project · Files

<?php
/**
 * CommentService.class.php
 * 活动评论信息表
 * @author: daijun
 * @copyright: vchangyi.com
 */

namespace Common\Service;

use Common\Common\AttachOperation;
use Common\Common\IntegralStrategy;
use Common\Common\Integral;
use Common\Common\Constant;
use Common\Common\Department;
use Common\Common\User;
use Common\Model\ActivityModel;
use Common\Model\AttachmentModel;
use Common\Model\CommentModel;
use Common\Model\CountModel;
use Common\Model\HistoryModel;
use Common\Model\LikeModel;
use Common\Model\LogModel;
use Common\Model\RightModel;
use Common\Common\Tag;

class CommentService extends AbstractService
{

    // 可以进行删除操作
    const IS_DEL_OK = 1;
    // 不可以进行删除
    const IS_DEL_NO = 0;

    // 已点赞
    const IS_LIKE_OK = 1;
    // 未点赞
    const IS_LIKE_NO = 0;

    // 回复每页条数
    const REPLY_LIMIT = 5;

    // 点赞类型为回复
    const COMMENT_TYPE = 2;

    // 上传图片个数最大值
    const IMAGES_COUNT = 9;

    // 一级评论
    const FIRST_COMMENT = 0;

    // 回复评论加权数
    const COMMENT_NUM = 1;

    // 默认获取点赞数
    const DEFAULT_LIKE_LIMIT = 12;

    // 回复活动类型
    const  RESTORE_ACTIVITY_TYPE = 1;
    // 回复回帖类型
    const  REPLIES_ARE_ANSWERED_TYPE = 2;
    // 帖子被回复类型
    const  REPLY_ARE_ANSWERED_TYPE = 3;

    // 首次
    const  COMMENT_FIRST = 1;

    // 已置顶
    const IS_TOP_TRUE = 1;
    // 未置顶
    const IS_TOP_FALSE = 0;

    /**
     * @var  User 用户公用类
     */
    protected $_user;

    /**
     * @var  LikeModel 点赞数据model
     */
    protected $_d_like;

    /**
     * @var  ActivityModel 活动数据model
     */
    protected $_d_activity;

    /**
     * @var  AttachmentModel 附件数据model
     */
    protected $_d_attach;

    /**
     * @var  RightModel 部门用户model
     */
    protected $_d_right;

    /**
     * @var  CountModel 回复统计表
     */
    protected $_d_count;

    /**
     * @var  LogModel 积分日志表
     */
    protected $_d_log;

    /**
     * @var  HistoryModel 历史日志表
     */
    protected $_d_history;


    // 构造方法
    public function __construct()
    {
        $this->_user = new User();

        $this->_d = new CommentModel();
        $this->_d_like = new LikeModel();
        $this->_d_activity = new ActivityModel();
        $this->_d_attach = new AttachmentModel();
        $this->_d_right = new RightModel();
        $this->_d_count = new CountModel();
        $this->_d_log = new LogModel();
        $this->_d_history = new HistoryModel();

        parent::__construct();
    }

    /**
     * 查询回复评论信息
     * @param $params array 查条件参数
     * @param $page_option array 分页参数
     * @param $uid String 用户UID
     * @return array|bool
     */
    public function replay_list($params, $page_option, $uid)
    {
        $comment_id = intval($params['comment_id']);
        // 判断评论ID是否存在
        if (!$comment_id) {

            E('_ERR_AC_REPLAY_EMPTY');
        }
        // 查询评论信息
        $comment_info = $this->get($comment_id);
        if (empty($comment_info)) {

            E('_ERR_DATA_NOT_EXIST');
        }
        // 查询发布评论的用户信息
        $user_info = $this->_user->getByUid($comment_info['uid']);
        $info = array(
            'uid' => strval($comment_info['uid']),
            'username' => strval($user_info['memUsername']),
            'avatar' => strval($user_info['memFace']),
            'content' => $this->Enter($comment_info['content']),
            'created' => $comment_info['created'],
            'likes' => intval($comment_info['likes']),
            'replys' => intval($comment_info['replys']),
        );

        //判断活动是否可以点赞
        $mylikecount = $this->_d_like->count_by_conds(array(
            'uid' => $uid,
            'cid' => $comment_id,
            'type' => self::COMMENT_TYPE,
        ));

        $is_like = $mylikecount ? self::IS_LIKE_OK : self::IS_LIKE_NO;

        $info['is_like'] = $is_like;
        // 获取评论点赞列表
        $info['like_list'] = $this->like_list($comment_id);

        // 获取评论附件列表
        $info['img_list'] = $this->img_list($comment_id);

        //查询回复总条数
        $conds = array('parent_id' => $comment_id);
        $order_option = array('created' => 'DESC');

        $total = $this->count_by_conds($conds);

        $list = [];
        if ($total > 0) {
            //查询回复列表
            $list = $this->list_by_conds($conds, $page_option, $order_option);

            if ($list) {
                // 回复列表数据格式化
                $list = $this->format_comment_list($list, $uid);
            }
        }

        $info['total'] = intval($total);
        $info['list'] = $list;

        return $info;
    }

    /**
     * 获取评论图片列表
     * @param $comment_id int 评论ID
     * @return array
     */
    protected function img_list($comment_id)
    {
        // 排序
        $order_option = array('created' => 'DESC');

        $list = $this->_d_attach->list_by_conds(
            array('cid' => $comment_id),
            null,
            $order_option
        );

        $images = [];
        foreach ($list as $v) {
            $images[] = array(
                'atId' => $v['at_id'],
                'imgUrl' => imgUrlReal($v['at_id']),
            );
        }

        return $images;
    }

    /**
     * 获取评论点赞列表int
     * @param  $comment_id int 评论ID
     * @return array
     */
    public function like_list($comment_id)
    {
        // 排序
        $order_option = array('created' => 'DESC');

        $like_list = $this->_d_like->list_by_conds(
            array('cid' => $comment_id, 'type' => self::COMMENT_TYPE),
            null,
            $order_option
        );

        $user_arr = [];
        if (!empty($like_list)) {

            $uids = array_column($like_list, 'uid');
            // 查询用户集合
            $users = $this->_user->listAll(array('memUids' => $uids));

            // 获取被删除的用户信息
            $this->user_list($users, $uids);

            $user_list = array_combine_by_key($users, 'memUid');

            // 格式化点赞列表数据
            foreach ($like_list as $val) {
                $value = [];

                $value['created'] = $val['created'];
                $value['like_id'] = $val['like_id'];
                $value['uid'] = $val['uid'];
                $value['username'] = $user_list[$val['uid']]['memUsername'];
                $value['avatar'] = $user_list[$val['uid']]['memFace'];

                $user_arr[] = $value;
            }
        }

        return $user_arr;
    }

    /**
     * 获取评论列表（后台）
     * @param array $result 返回活动信息
     * @param array $reqData 请求数据
     * @return bool
     */
    public function comment_list(&$result, $reqData)
    {

        $ac_id = intval($reqData['ac_id']);
        $parent_id = intval($reqData['parent_id']);

        if (empty($ac_id)) {

            E('_ERR_AC_ID_EMPTY');
        }

        // 默认值
        $page = isset($reqData['page']) ? intval($reqData['page']) : self::DEFAULT_PAGE;
        // 默认每页条数
        if ($parent_id > 0) {

            $limit = isset($reqData['limit']) ? intval($reqData['limit']) : self::REPLY_LIMIT;
        } else {

            $limit = isset($reqData['limit']) ? intval($reqData['limit']) : self::DEFAULT_LIMIT;
        }

        // 分页
        list($start, $limit) = page_limit($page, $limit);

        // 排序
        $order_option = array('top_time' => 'DESC', 'created' => 'DESC');

        // 分页
        $page_option = array($start, $limit);

        // 查询总记录数
        $total = $this->_d->count_by_conds(array('ac_id' => $ac_id, 'parent_id' => $parent_id));

        // 查询列表
        $list = [];
        if ($total > 0) {

            $comm_list = $this->_d->list_by_conds(array('ac_id' => $ac_id, 'parent_id' => $parent_id), $page_option,
                $order_option);
            // 格式化列表数据
            $list = $this->format_comment_list_admin($comm_list);
        }

        $result = array(
            'page' => $page,
            'limit' => $limit,
            'total' => (int)$total,
            'lists' => $list,
        );

        return true;
    }

    /**
     * 格式化评论列表数据（前台）
     * @param array $comm_list 评论数据
     * @param string $uid 用户ID
     * @return array
     */
    public function format_comment_list($comm_list = [], $uid = '')
    {
        // 获取用户ID集合
        $uids = array_column($comm_list, 'uid');

        // 查询用户列表
        $user_list = $this->_user->listAll(array('memUids' => $uids));

        // 获取被删除的用户信息
        $this->user_list($user_list, $uids);

        // 将用户列表转换为以uid为key的二维数组
        $users = array_combine_by_key($user_list, 'memUid');

        // 查询该用户点赞的所有评论
        $like_list = $this->_d_like->list_by_conds(array('type' => LikeModel::TYPE_COMMENT, 'uid' => $uid));

        // 点赞的评论ID集合
        $like_cids = array_column($like_list, 'cid');

        // 获取评论ID集合
        $comment_ids = array_column($comm_list, 'comment_id');

        $attach_list = [];
        if (!empty($comment_ids)) {
            // 查询附件集合
            $attach_list = $this->_d_attach->list_by_conds(array('cid' => $comment_ids));
        }

        foreach ($comm_list as &$v) {

            // 转换数据返回格式
            $v['comment_id'] = intval($v['comment_id']);
            $v['likes'] = intval($v['likes']);
            $v['comments'] = intval($v['replys']);
            $v['is_attach'] = intval($v['is_attach']);
            $v['content'] = $this->Enter($v['content']);

            // 组装用户数据
            $v['uid'] = strval($v['uid']);
            $v['username'] = strval($users[$v['uid']]['memUsername']);
            $v['avatar'] = strval($users[$v['uid']]['memFace']);

            // 格式化时间
            $v['created'] = $this->get_time($v['created']);

            // 组装是否可删除标识
            if ($v['uid'] == $uid) {
                $v['is_del'] = self::IS_DEL_OK;
            } else {
                $v['is_del'] = self::IS_DEL_NO;
            }

            // 组装是否已点赞标识
            if (in_array($v['comment_id'], $like_cids)) {
                $v['is_like'] = self::IS_LIKE_OK;
            } else {
                $v['is_like'] = self::IS_LIKE_NO;
            }

            // 获取评论图片信息
            $images = [];
            foreach ($attach_list as $_v) {
                // 如果是本评论的附件
                if ($_v['cid'] == $v['comment_id']) {
                    $images[] = array(
                        'atId' => $_v['at_id'],
                        'imgUrl' => imgUrlReal($_v['at_id']),
                    );
                    // 清除该条记录
                    unset($_v);
                }
            }

            $v['images'] = $images;

            // 是否被置顶
            $v['is_top'] = $v['top_time'] ? self::IS_TOP_TRUE : self::IS_TOP_FALSE;

            // 删除多余数据
            unset(
                $v['top_time'],
                $v['parent_id'],
                $v['ac_id'],
                $v['replys'],
                $v['domain'],
                $v['status'],
                $v['updated'],
                $v['deleted']
            );

        }

        return $comm_list;
    }

    /**
     * 格式化评论列表数据（后台）
     * @param $comm_list array 评论列表数据
     * @return array
     */
    public function format_comment_list_admin(&$comm_list)
    {

        // 获取用户ID集合
        $uids = array_column($comm_list, 'uid');

        // 查询用户列表
        $user_list = $this->_user->listAll(array('memUids' => $uids));

        // 获取被删除的用户信息
        $this->user_list($user_list, $uids);

        // 将用户列表转换为以uid为key的二维数组
        $users = array_combine_by_key($user_list, 'memUid');

        // 获取评论ID集合
        $comment_ids = array_column($comm_list, 'comment_id');

        $attach_list = [];
        if (!empty($comment_ids)) {
            // 查询附件集合
            $attach_list = $this->_d_attach->list_by_conds(array('cid' => $comment_ids));
        }

        foreach ($comm_list as &$v) {

            $v['ac_id'] = (int)$v['ac_id'];
            $v['comment_id'] = (int)$v['comment_id'];
            $v['parent_id'] = (int)$v['parent_id'];
            $v['likes'] = (int)$v['likes'];
            $v['replys'] = (int)$v['replys'];
            $v['username'] = (string)$users[$v['uid']]['memUsername'];
            $v['avatar'] = $users[$v['uid']]['memFace'];
            $v['content'] = $this->Enter($v['content']);
            $v['is_top'] = $v['top_time'] ? self::IS_TOP_TRUE : self::IS_TOP_FALSE;

            // 获取评论图片信息
            $images = [];

            foreach ($attach_list as $_v) {
                // 如果是本评论的附件
                if ($_v['cid'] == $v['comment_id']) {
                    $images[] = array(
                        'atId' => $_v['at_id'],
                        'imgUrl' => imgUrlReal($_v['at_id']),
                    );
                    // 清除该条记录
                    unset($_v);
                }
            }

            $v['images'] = $images;

            // 获取一级评论的回复列表
            if ($v['parent_id'] == self::FIRST_COMMENT && $v['replys'] > 0) {

                $v['reply_lists'] = $this->_d->list_by_conds(
                    array(
                        'ac_id' => $v['ac_id'],
                        'parent_id' => $v['comment_id'],
                    ),
                    array(
                        self::FIRST_COMMENT,
                        self::REPLY_LIMIT,
                    ),
                    array(
                        'created' => 'DESC',
                    ),
                    'comment_id,uid,content,is_attach,likes,replys,created'
                );
            }

            // 获取回复用户信息及附件信息
            if ($v['reply_lists']) {

                // 获取回复用户ID集合
                $reply_uids = array_column($v['reply_lists'], 'uid');

                // 查询回复用户列表
                $reply_user_list = $this->_user->listAll(array('memUids' => $reply_uids));

                // 获取被删除的用户信息
                $this->user_list($reply_user_list, $reply_uids);

                // 将用户列表转换为以uid为key的二维数组
                $reply_users = array_combine_by_key($reply_user_list, 'memUid');

                // 获取回复ID集合
                $reply_ids = array_column($v['reply_lists'], 'comment_id');

                $reply_attach_list = [];
                if (!empty($reply_ids)) {
                    // 查询附件集合
                    $reply_attach_list = $this->_d_attach->list_by_conds(array('cid' => $reply_ids));
                }

                foreach ($v['reply_lists'] as &$reply) {

                    $reply['comment_id'] = (int)$reply['comment_id'];
                    $reply['likes'] = (int)$reply['likes'];
                    $reply['replys'] = (int)$reply['replys'];
                    $reply['username'] = (string)$reply_users[$reply['uid']]['memUsername'];
                    $reply['avatar'] = $reply_users[$reply['uid']]['memFace'];
                    $reply['content'] = $this->Enter($reply['content']);

                    // 获取评论图片信息
                    $reply_images = [];

                    foreach ($reply_attach_list as $_reply) {
                        // 如果是本评论的附件
                        if ($_reply['cid'] == $reply['comment_id']) {
                            $reply_images[] = array(
                                'atId' => $_reply['at_id'],
                                'imgUrl' => imgUrlReal($_reply['at_id']),
                            );
                            // 清除该条记录
                            unset($_reply);
                        }
                    }

                    $reply['images'] = $reply_images;
                }
            }

            // 删除多余数据
            unset($v['top_time'], $v['domain'], $v['status'], $v['updated'], $v['deleted']);
        }

        return $comm_list;
    }

    /**
     * 前端删除我的评论
     * @param $comment_id
     * @param string $uid 前端登录用户ID
     * @return bool
     */
    public function del_comment($comment_id, $uid = '')
    {
        // 查询评论数据
        $data = $this->_d->get($comment_id);

        // 如果数据不存在
        if (empty($data)) {

            E('_ERR_DATA_NOT_EXIST');
        }

        // 活动已结束不能删除
        $activity = $this->_d_activity->get($data['ac_id']);
        if (($activity['end_time'] < MILLI_TIME || ActivityService::STOP_ACTIVITY == $activity['activity_status']) && $data['parent_id'] == 0 && $uid&& ActivityService::ROUTINE_TYPE==$activity['activity_type']) {

            E('_ERR_ACTIVITY_END');
        }

        // 如果不是自己发布的，则不能删除
        if (!empty($uid) && ($uid != $data['uid'])) {

            E('_ERR_COMMENT_FORYOU');
        }

        try {
            // 开始事务
            $this->start_trans();

            // 删除评论
            $this->_d->delete($comment_id);

            //删除评论附件
            $this->_d_attach->delete_by_conds(array('cid' => $comment_id));

            //删除评论点赞
            $this->_d_like->delete_by_conds(array('cid' => $comment_id));

            // 如果评论是一级评论
            if (self::FIRST_COMMENT == $data['parent_id']) {

                // 查询该评论下的所有回复
                $replay_list = $this->_d->list_by_conds(array('parent_id' => $comment_id));

                // 获取该评论回复的ID集合
                $comment_ids = array_column($replay_list, 'comment_id');

                if (!empty($comment_ids)) {
                    // 删除回复
                    $this->_d->delete_by_conds(array('parent_id' => $comment_id));

                    //删除回复附件
                    $this->_d_attach->delete_by_conds(array('cid in (?)' => $comment_ids));

                    //删除回复点赞
                    $this->_d_like->delete_by_conds(array('cid in (?)' => $comment_ids));
                }

                // 此处给该活动的评论数减1
                $this->_d_activity->update($data['ac_id'], array('comments = comments-?' => 1));

            } else {
                // 此处给该评论的评论数减1
                $this->_d->update($data['parent_id'], array('replys = replys-?' => 1));
            }

            // 提交事务
            $this->commit();

        } catch (\Think\Exception $e) {
            \Think\Log::record($e);
            // 事务回滚
            $this->_set_error($e->getMessage(), $e->getCode());
            $this->rollback();

            return false;
        } catch (\Exception $e) {

            \Think\Log::record($e);
            $this->_set_error($e->getMessage(), $e->getCode());
            // 事务回滚
            $this->rollback();

            return false;
        }

        // 附件操作
        $attach_serv = new AttachOperation();
        $attach_serv->delete_attach(APP_DIR, 'comment', [$comment_id]);

        return true;
    }

    /**
     * 发布评论和回复评论接口
     * @param array $data 评论的数据
     * @param string $uid 评论人UID
     * @param string $username 评论人姓名
     * @param array $activity 活动信息
     * @return mixed
     */
    public function publish_comment($data = [], $uid = '', $username = '', $activity = [])
    {
        $ac_id = intval($data['ac_id']);
        $piclist = $data['images'];
        $content = trim($data['content']);
        $comment_id = intval($data['comment_id']);
        $images = array_column($piclist, 'atId');

        //活动ID必须大于0
        if (!$ac_id) {

            E('_ERR_AC_ID_EMPTY');
        }

        $content_length = $comment_id ? 500 : 1000;
        //判断评论内容长度
        if (!\Com\Validator::is_len_in_range($content, 2, $content_length, 'utf-8')) {

            $comment_id ? E('_ERR_AC_COMMENT_LENGTH') : E('_ERR_AC_POST_LENGTH');
        }

        $pic_total = count($images);
        $is_attach = $pic_total ? 1 : 0;

        // 上传图片数量是否大于上传图片个数最大值
        if ($pic_total > self::IMAGES_COUNT) {

            E('_ERR_AC_IMAGE_LENGTH');
        }

        // 初始化
        $news_cid = 0;

        try {
            // 开始事务
            $this->_d->start_trans();

            //插入评论信息
            $news_cid = $this->_d->insert(array(
                'ac_id' => $ac_id,
                'parent_id' => $comment_id,
                'content' => $content,
                'is_attach' => $is_attach,
                'uid' => $uid,
            ));

            // 组装当前用户条件
            $condition = array('uid' => $uid);

            // 查询当前用户是否有评论统计记录
            $user_total = $this->_d_count->get_by_conds($condition);

            if (empty($user_total)) {

                $this->_d_count->insert($condition);
            }

            // 开启积分策略
            if (self::INTEGRAL_ACTION_TYPE_NO != $activity['integral_action_type']) {

                // 如果是回帖
                if (self::FIRST_COMMENT == $comment_id) {

                    // 更新楼层
                    $this->update_floor($ac_id, $news_cid);

                    // 更新回帖数和回帖次数
                    $this->update_reply($uid, $ac_id);
                } else {

                    // 更新回复次数以及回复个数,回帖被回复次数以及个数
                    $this->update_answer($uid, $comment_id);
                }
            }

            // 如果有附件
            if ($is_attach) {
                // 组装附件信息数组
                $attach_list = [];
                foreach ($images as $v) {
                    if (!empty(trim($v))) {
                        $attach_list[] = array('cid' => $news_cid, 'at_id' => $v);
                    }
                }
                // 插入附件信息
                if (!empty($attach_list)) {
                    $this->_d_attach->insert_all($attach_list);
                }
            }
            if (!$comment_id) {

                $update_data = [
                    'comments=comments+(?)' => self::COMMENT_NUM,
                ];

                // 当前用户是否发布过评论
                $conds = [
                    'ac_id' => $ac_id,
                    'parent_id' => 0,
                    'uid' => $uid,
                ];
                $is_comment = $this->_d->count_by_conds($conds);

                if ($is_comment == 1) {
                    // 如果是第一次发表评论则更新活动表的已参与人数和未参与人数
                    $update_data['join_total=join_total+(?)'] = 1;
                    $update_data['unjoin_total=unjoin_total-(?)'] = 1;
                }

                //更新活动
                $this->_d_activity->update($ac_id, $update_data);

            } else {
                //评论回复
                $this->_d->update($comment_id, array("replys=replys+(?)" => self::COMMENT_NUM));
            }

            //评论消息回复
            $this->comment_send_msg($ac_id, $comment_id, $content, $username);

            //提交修改
            $this->_d->commit();

        } catch (\Think\Exception $e) {
            \Think\Log::record($e);

            $this->_d->rollback();

        } catch (\Exception $e) {
            \Think\Log::record($e);
            $this->_d->rollback();
        }

        // 附件操作
        if (!empty($images)) {
            $attach_serv = new AttachOperation();
            $attach_serv->insert_attach(
                APP_DIR,
                'comment',
                $news_cid,
                ['attach_ids' => $images]
            );
        }

        return $news_cid;

    }

    /**
     * 更新回复次数以及回复个数,回帖被回复次数以及个数
     * @param string $uid 当前用户UID
     * @param string $comment_id 上级ID
     * @return bool
     */
    protected function update_answer($uid = '', $comment_id = '')
    {
        // 组装当前用户条件
        $condition = array('uid' => $uid);

        // 组装查询回帖条件
        $where = array(
            'comment_id' => $comment_id,
            'parent_id' => self::FIRST_COMMENT
        );

        // 查询是否为帖子
        $info = $this->get_by_conds($where);

        // 如果是帖子
        if (!empty($info)) {

            // 组装回帖人数据
            $replies_where = array('uid' => $info['uid']);

            // 查询当前用户是否有评论统计记录
            $replies_total = $this->_d_count->count_by_conds($replies_where);

            if (empty($replies_total)) {

                $this->_d_count->insert($replies_where);
            }

            // 更新回复次数
            $this->_d_count->update_by_conds(
                $condition,
                array(
                    "answer_total=answer_total+(?)" => self::COMMENT_NUM
                ));

            // 回帖被回复次数
            $this->_d_count->update_by_conds(
                $replies_where,
                array(
                    "replies_total=replies_total+(?)" => self::COMMENT_NUM
                ));

            // 回复回帖组装条件
            $reply_card = array(
                'uid' => $uid,
                'ac_id' => $info['ac_id'],
                'pid' => $comment_id,
                'type' => self::REPLIES_ARE_ANSWERED_TYPE,
                'post_man' => $info['uid']
            );

            $reply_total = $this->_d_history->get_by_conds($reply_card);

            // 如果刚刚插入回帖数
            if (empty($reply_total)) {

                // 更新回帖个数
                $this->_d_count->update_by_conds(
                    $condition,
                    array(
                        "answer_num=answer_num+(?)" => self::COMMENT_NUM
                    ));

                // 回帖被回复个数
                /*  $this->_d_count->update_by_conds(
                      $replies_where,
                      array(
                          "replies_num=replies_num+(?)" => self::COMMENT_NUM
                      ));
                */

            }

            // 回复贴子记录
            $this->_d_history->insert($reply_card);

            // 回帖被回复记录
            $commit_data = array(
                'uid' => $info['uid'],
                'ac_id' => $info['ac_id'],
                'pid' => $comment_id,
                'type' => self::REPLY_ARE_ANSWERED_TYPE
            );

            // 回帖被回复记录
            $this->_d_history->insert($commit_data);

        }

        return true;
    }

    /**
     * 更新回帖数和回帖次数
     * @param string $uid 当前用户UID
     * @param string $ac_id 活动ID
     * @return bool
     */
    protected function update_reply($uid = '', $ac_id = '')
    {

        // 条件
        $condition = array('uid' => $uid);

        // 回帖查询
        $restore_cond = array(
            'uid' => $uid,
            'ac_id' => $ac_id,
            'pid' => self::FIRST_COMMENT,
            'type' => self::RESTORE_ACTIVITY_TYPE
        );

        // 查询是否回复过此话题
        $reply_total = $this->_d_history->count_by_conds($restore_cond);

        // 查询是否回复过此活动
        if (empty($reply_total)) {

            // 更新回复活动数
            $this->_d_count->update_by_conds(
                $condition,
                array(
                    "reply_num=reply_num+(?)" => self::COMMENT_NUM
                ));
        }

        // 写入历史记录
        $this->_d_history->insert($restore_cond);

        // 回复活动次数
        $this->_d_count->update_by_conds(
            $condition,
            array(
                "reply_total=reply_total+(?)" => self::COMMENT_NUM
            ));

        return true;

    }

    /**
     * 更新楼层数
     * @param string $ac_id 活动ID
     * @param string $news_cid 帖子ID
     * @return bool
     */
    protected function update_floor($ac_id = '', $news_cid = '')
    {

        //插入评论信息
        $info = $this->_d_activity->get($ac_id);

        if (!empty($info)) {
            // 插入楼层信息
            $this->_d->update($news_cid, array('sort' => intval($info['floor']) + 1));
            // 更新楼层数
            $this->_d_activity->update($ac_id, array("floor=floor+(?)" => self::COMMENT_NUM));
        }

        return true;
    }

    /**
     * 前端回复评论消息
     * @param int $ac_id 活动ID
     * @param int $comment_id 评论ID(有则评论回复)
     * @param string $reply_content 回复内容
     * @param string $username 回复人姓名
     * @return bool
     */
    public function comment_send_msg($ac_id = 0, $comment_id = 0, $reply_content = '', $username = '')
    {
        //批判断活动ID是否存在
        if (!$ac_id) {

            return false;
        }
        $activity = $this->_d_activity->get($ac_id);
        $data = [];
        //判断是否发送评论回复消息
        if ($activity['is_notice'] && $comment_id) {
            //查询要回复评论的UID
            $comment = $this->_d->get($comment_id);

            //给评论人提醒有回复
            $data['uids'] = $comment['uid'];
            $data['subject'] = $activity['subject'];
            $data['content'] = $reply_content;
            $data['username'] = $username;
            $data['cid'] = $comment_id;

            $this->send_msg($data, self::MSG_COMMENT_REPLY);
        }

        return false;
    }

    /**
     * 获取积分信息
     * @param array $params POST参数
     * @param string $uid 当前UID
     * @param string $id 评论ID
     * @return array
     */
    public function get_integral_msg($params = [], $uid = '', $id = '')
    {
        // 策略ID集合
        $key_ids = [];
        $credit_key_ids = [];

        // 初始化返回消息
        $msg = [];
        // 实例积分
        $service = new Integral();

        // 获取活动详情
        $activity_info = $this->_d_activity->get($params['ac_id']);

        // 不使用策略
        if (self::INTEGRAL_ACTION_TYPE_NO == $activity_info['integral_action_type'] && self::INTEGRAL_ACTION_TYPE_NO == $activity_info['credit_action_type']) {

            return [];
        }

        // 自定义策略
        if (self::INTEGRAL_ACTION_TYPE_MY == $activity_info['integral_action_type']) {

            $key_ids = unserialize($activity_info['integral_strategyid']);
            $key_ids = array_combine_by_key($key_ids, 'businesskact');
        }

        // 自定义策略
        if (self::INTEGRAL_ACTION_TYPE_MY == $activity_info['credit_action_type']) {

            $credit_key_ids = unserialize($activity_info['credit_strategyid']);
            $credit_key_ids = array_combine_by_key($credit_key_ids, 'businesskact');
        }

        // 我评论的详情
        $ac_info = $this->get_by_conds(array('comment_id' => $id));

        // 发布话题用户记录详情
        $info = $this->_d_count->get_by_conds(array('uid' => $uid));

        // 如果是回帖
        if (self::FIRST_COMMENT == $params['comment_id']) {

            // 楼层KEY
            $reply_floor_key = 'reply_floor' . $params['ac_id'];
            // 回帖KEY
            $comment_key = 'reply_floor_range' . $params['ac_id'];

            // 楼层积分规则
            $integral_data = array(
                'msgIdentifier' => APP_IDENTIFIER,
                'memUid' => $uid,
                'businessKey' => 'active_center',
                'businessAct' => 'reply_floor',
                'businessId' => $reply_floor_key,
                'triggers' => [
                    [
                        'miType' => IntegralStrategy::TRIGGER_TYPE_INTEGRAL,
                        'businessStrategyId' => strval($key_ids['reply_floor']['eibsid']),
                        'triggerTypes' => [
                            [
                                'triggerKey' => 'number',
                                'value' => intval($ac_info['sort']),
                                'remark' => '回帖楼层数'
                            ],
                            [
                                'triggerKey' => 'reply_floor_range',
                                'value' => intval($ac_info['sort']),
                                'remark' => '回帖楼层区间'
                            ]
                        ]
                    ]
                ],
            );

            // 回帖次数
            $answered[] = array(
                'triggerKey' => 'number',
                'value' => intval($info['reply_total']),
                'remark' => '回帖次数'
            );

            // 查询回帖记录
            $reply_cond = array(
                'uid' => $uid,
                'ac_id' => $params['ac_id'],
                'pid' => self::FIRST_COMMENT,
                'type' => self::RESTORE_ACTIVITY_TYPE
            );

            // 查询是否回复过此话题
            $reply_total = $this->_d_history->count_by_conds($reply_cond);

            // 如果是首次回复
            if (self::COMMENT_FIRST == $reply_total) {
                $answered[] = array(
                    'triggerKey' => 'reply_business_num',
                    'value' => intval($info['reply_num']),
                    'remark' => '回复活动数'
                );
            }

            // 回帖积分规则
            $reply_data = array(
                'msgIdentifier' => APP_IDENTIFIER,
                'memUid' => $uid,
                'businessKey' => 'active_center',
                'businessAct' => 'answered',
                'businessId' => $comment_key,
                'triggers' => [
                    [
                        'miType' => IntegralStrategy::TRIGGER_TYPE_INTEGRAL,
                        'businessStrategyId' => strval($key_ids['answered']['eibsid']),
                        'triggerTypes' => $answered,
                    ]
                ],
            );

            // 楼层数据
            $was_comment = array(
                'uid' => $uid,
                'pid' => $id,
                'businessId' => $reply_floor_key
            );

            // 楼层日志
            $this->_d_log->insert($was_comment);

            // 回帖数据
            $comment = array(
                'uid' => $uid,
                'pid' => $id,
                'businessId' => $comment_key
            );

            // 回帖日志
            $this->_d_log->insert($comment);

            // 统一触发积分策略
            if (self::INTEGRAL_ACTION_TYPE_NO != $activity_info['integral_action_type']) {
                $integral_msg = $service->changeScore($integral_data);
                $reply_msg = $service->changeScore($reply_data);
            }

            // 统一触发学分策略
            if (self::INTEGRAL_ACTION_TYPE_NO != $activity_info['credit_action_type']) {
                $integral_data['triggers'][0]['miType'] = IntegralStrategy::TRIGGER_TYPE_CREDIT;
                $integral_data['triggers'][0]['businessStrategyId'] = strval($credit_key_ids['reply_floor']['eibsid']);
                $credit_msg = $service->changeScore($integral_data);

                $reply_data['triggers'][0]['miType'] = IntegralStrategy::TRIGGER_TYPE_CREDIT;
                $reply_data['triggers'][0]['businessStrategyId'] = strval($credit_key_ids['answered']['eibsid']);
                $credit_reply_msg = $service->changeScore($reply_data);
            }

            // 合并消息
            $msg = array_merge($integral_msg, $reply_msg, $credit_msg, $credit_reply_msg);

        } else {

            // 组装查询回帖条件
            $where = array(
                'comment_id' => $params['comment_id'],
                'parent_id' => self::FIRST_COMMENT
            );

            // 查询是否为帖子
            $comment_info = $this->get_by_conds($where);

            if (!empty($comment_info)) {

                // 话题被评论KEY
                $reply_key = 'active_' . $id . '_' . rand(0, 9999);

                // 话题被评论KEY
                $comment_key = 'active_' . $id . '_' . rand(0, 9999);

                // 回复回帖数组
                $triggerTypes[] = array(
                    'triggerKey' => 'number',
                    'value' => intval($info['answer_total']),
                    'remark' => '回复回帖次数'
                );

                // 发布话题用户回帖被回复数据
                $reply_info = $this->_d_count->get_by_conds(array('uid' => $comment_info['uid']));

                // 回帖被回复次数
                $was_reply_data[] = array(
                    'triggerKey' => 'number',
                    'value' => intval($reply_info['replies_total']),
                    'remark' => '回帖被回复次数'
                );

                // 回复当前回帖次数判断
                $restore_cond = array(
                    'uid' => $uid,
                    'ac_id' => $params['ac_id'],
                    'pid' => $params['comment_id'],
                    'type' => self::REPLIES_ARE_ANSWERED_TYPE
                );

                // 查询是否回复过此话题
                $restore_total = $this->_d_history->count_by_conds($restore_cond);

                // 如果回复回帖数
                if (self::COMMENT_FIRST == $restore_total) {

                    $triggerTypes[] = array(
                        'triggerKey' => 'reply_business_num',
                        'value' => intval($info['answer_num']),
                        'remark' => '回复回帖个数'
                    );

                    $was_reply_where = array(
                        'post_man' => $comment_info['uid'],
                        'type' => self::REPLIES_ARE_ANSWERED_TYPE
                    );

                    // 查询所以被回复记录UID去重统计
                    $list = $this->_d_history->list_by_conds($was_reply_where, null, [], 'uid');

                    // 所有的回帖人
                    $uids = array_unique(array_column($list, 'uid'));

                    // 回帖被回复数组
                    $was_reply_data[] = array(
                        'triggerKey' => 'was_reply_num',
                        'value' => count($uids),
                        'remark' => '回帖被回复个数'
                    );
                }

                // 回复回帖
                $reply_data = [
                    'msgIdentifier' => APP_IDENTIFIER,
                    'memUid' => $uid,
                    'businessKey' => 'active_center',
                    'businessAct' => 'reply',
                    'businessId' => $reply_key,
                    'triggers' => [
                        [
                            'miType' => IntegralStrategy::TRIGGER_TYPE_INTEGRAL,
                            'businessStrategyId' => strval($key_ids['reply']['eibsid']),
                            'triggerTypes' => $triggerTypes,
                        ]
                    ],
                ];

                // 回帖被回复积分规则
                $answer_data = [
                    'msgIdentifier' => APP_IDENTIFIER,
                    'memUid' => $comment_info['uid'],
                    'businessKey' => 'active_center',
                    'businessAct' => 'was_reply',
                    'businessId' => $comment_key,
                    'triggers' => [
                        [
                            'miType' => IntegralStrategy::TRIGGER_TYPE_INTEGRAL,
                            'businessStrategyId' => strval($key_ids['was_reply']['eibsid']),
                            'triggerTypes' => $was_reply_data,
                        ]
                    ],
                ];

                // 回复帖子日志
                $reply = array(
                    'uid' => $uid,
                    'pid' => $id,
                    'businessId' => $reply_key
                );

                // 回复帖子
                $this->_d_log->insert($reply);

                // 帖子被回复日志
                $was_reply = array(
                    'uid' => $comment_info['uid'],
                    'pid' => $id,
                    'businessId' => $comment_key
                );

                // 帖子被回复日志
                $this->_d_log->insert($was_reply);

                // 统一触发积分策略
                if (self::INTEGRAL_ACTION_TYPE_NO != $activity_info['integral_action_type']) {
                    $service->changeScore($answer_data);
                    $integral_msg = $service->changeScore($reply_data);
                }

                // 统一触发学分策略
                if (self::INTEGRAL_ACTION_TYPE_NO != $activity_info['credit_action_type']) {
                    $answer_data['triggers'][0]['miType'] = IntegralStrategy::TRIGGER_TYPE_CREDIT;
                    $answer_data['triggers'][0]['businessStrategyId'] = strval($credit_key_ids['was_reply']['eibsid']);
                    $service->changeScore($answer_data);

                    $reply_data['triggers'][0]['miType'] = IntegralStrategy::TRIGGER_TYPE_CREDIT;
                    $reply_data['triggers'][0]['businessStrategyId'] = strval($credit_key_ids['reply']['eibsid']);
                    $credit_msg = $service->changeScore($reply_data);
                }

                // 如果是回复
                $msg = array_merge($integral_msg, $credit_msg);
            }
        }

        // 获取返回消息
        return $this->msg_list($msg);
    }

    /**
     * 管理后台活动已参与列表
     *
     * @param $params
     *
     * @return mixed
     */
    public function list_join($params)
    {

        // 默认值
        $page = !empty($params['page']) ? intval($params['page']) : self::DEFAULT_PAGE;
        $limit = !empty($params['limit']) ? intval($params['limit']) : self::DEFAULT_LIMIT;

        // 分页
        list($start, $limit) = page_limit($page, $limit);

        // 按照发布时间排序
        $order_option = ['created' => 'DESC'];

        // 查询条件
        $conds = ['ac_id' => $params['ac_id'], 'parent_id' => 0];
        $join_list = $this->_d->list_join($conds, [$start, $limit], $order_option);
        $uids = array_column($join_list, 'uid');

        $user_s = new User();
        $user_list = $user_s->listByUid($uids);

        foreach ($join_list as $join_k => $join_v) {
            // 获取用户信息
            $user_info = $user_list[$join_v['uid']];
            // 获取被删除的用户信息
            if (empty($user_info)) {

                $user_info = $user_s->getByUid($join_v['uid']);
            }

            $join_list[$join_k]['memId'] = $join_v['uid'];
            $join_list[$join_k]['memUsername'] = $user_info['memUsername'];
            $join_list[$join_k]['dpName'] = $user_info['dpName'][0]['dpName'];
            $join_list[$join_k]['roleName'] = $user_info['memRole'];
            $join_list[$join_k]['jobName'] = $user_info['memJob'];
            $join_list[$join_k]['telephone'] = $user_info['memMobile'];
            $join_list[$join_k]['last_join_time'] = $join_v['created'];
            $join_list[$join_k]['tagName'] = $user_info['memTag'];
        }

        return $join_list;
    }

    /**
     * 获取活动已参与人数
     *
     * @param array $params 过滤条件
     *
     * @return mixed
     */
    public function count_join($params)
    {

        $conds = [
            'ac_id' => $params['ac_id'],
            'parent_id' => 0,
        ];

        return $this->_d->count_join($conds);
    }

    /**
     * 获取活动未参与列表
     *
     * @param array $params 过滤条件
     * @param array $unjoin_uids 未参与的uid集合数组
     *
     * @return array
     */
    public function list_unjoin($params, $unjoin_uids)
    {
        // 数组分页
        $page = !empty($params['page']) ? intval($params['page']) : self::DEFAULT_PAGE;
        $limit = !empty($params['limit']) ? intval($params['limit']) : self::DEFAULT_LIMIT;
        //计算每次分页的开始位置
        $start_limt = ($page - 1) * $limit;
        $uids = array_slice($unjoin_uids, $start_limt, $limit);

        // 查询用户信息
        $user_s = new User();
        $unjoin_user_list = $user_s->listByUid($uids);

        $unjoin_list = [];
        foreach ($unjoin_user_list as $user_v) {

            $unjoin_list[] = [
                'memId' => $user_v['memUid'],
                'memUsername' => $user_v['memUsername'],
                'dpName' => $user_v['dpName'][0]['dpName'],
                'roleName' => $user_v['memRole'],
                'jobName' => $user_v['memJob'],
                'telephone' => $user_v['memMobile'],
                'tagName' => $user_v['memTag']
            ];
        }

        return $unjoin_list;
    }

    /**
     * 获取活动未参与人数
     *
     * @param array $params 过滤条件
     *
     * @return array
     */
    public function count_unjoin($params)
    {
        // 获取权限内总人数
        $right_m = new RightModel();
        $right_conds = [
            'ac_id' => $params['ac_id'],
        ];
        $right_list = $right_m->list_by_conds($right_conds);
        $right_service = new RightService();
        $right_data = $right_service->format_db_data($right_list);
        $right_data['is_all'] = $params['is_all'];
        $right_uids = $right_service->list_uids_by_right($right_data);

        // 获取已参与人员
        $join_list = $this->_d->list_join(['ac_id' => $params['ac_id']]);
        // 剔除已参与的人员
        $join_uids = array_column($join_list, 'uid');
        $unjoin_uids = array_diff($right_uids, $join_uids);

        return [
            'unjoin_uids' => $unjoin_uids, // 未参与的uid数组
            'unjoin_num' => count($unjoin_uids), // 未参与人数
        ];
    }

    /**
     * 获取活动参与情况数据
     *
     * @param array $params 参数列表
     * @param array $unjoin_uids 未参与人员id集合
     *
     * @return array
     */
    public function export_join_data($params, $unjoin_uids = [])
    {

        $list = [];
        $user_s = new User();

        // 已参与
        if (Constant::ACTIVITY_JOIN_TYPE_TRUE == $params['is_join']) {
            // 排序
            $order_option = ['comment_id' => 'DESC'];
            // 查询条件
            $conditions = [
                'ac_id' => $params['ac_id'],
                'parent_id' => 0
            ];
            $join_list = $this->_d->list_join($conditions, [], $order_option);

            $uids = array_unique(array_column($join_list, 'uid'));
            $user_list = $user_s->listByUid($uids);

            foreach ($join_list as $join_k => $join_v) {
                // 用户信息
                $user_info = $user_list[$join_v['uid']];
                // 获取被删除的用户信息
                if (empty($user_info)) {

                    $user_info = $user_s->getByUid($join_v['uid']);
                }

                // 部门路径
                $departmentPath = Department::instance()->getCdNames($user_info['dpName'][0]['dpId']);

                $list[] = [
                    'memUsername' => $user_info['memUsername'],
                    'dpName' => $departmentPath,
                    'jobName' => $user_info['memJob'],
                    'roleName' => $user_info['memRole'],
                    'telephone' => $user_info['memMobile'],
                    'last_join_time' => rgmdate($join_v['created'], 'Y-m-d H:i')
                ];
            }
        } elseif (Constant::ACTIVITY_JOIN_TYPE_FALSE == $params['is_join']) { // 未参与
            // 查询用户信息
            $unjoin_user_list = $user_s->listByUid($unjoin_uids);

            foreach ($unjoin_user_list as $unjoin_user) {
                // 部门路径
                $departmentPath = Department::instance()->getCdNames($unjoin_user['dpName'][0]['dpId']);

                $list[] = [
                    'memUsername' => $unjoin_user['memUsername'],
                    'dpName' => $departmentPath,
                    'jobName' => $unjoin_user['memJob'],
                    'roleName' => $unjoin_user['memRole'],
                    'telephone' => $unjoin_user['memMobile']
                ];
            }
        }

        return $list;
    }
}