im/src/server/models/sessions/topics.js

/**
 * 议题模型。
 */
"use strict";

let RedisClient = require('../../repository/redis/redis.client.js');
let TopicsRepo = require('../../repository/mysql/topics.repo');
let SessionRepo = require('../../repository/mysql/session.repo');
let ParticipantRepo = require('../../repository/mysql/participant.repo');
let RedisModel = require('./../redis.model.js');
let ModelUtil = require('../../util/model.util');
let Participants = require("./participants");
let Sessions = require("./sessions");

let log = require('../../util/log.js');
let redis = RedisClient.redisClient().connection;
let configFile = require('../../include/commons').CONFIG_FILE;
let config = require('../../resources/config/' + configFile);

const REDIS_KEYS = require('../../include/commons').REDIS_KEYS;
const TOPIC_STATUS = require('../../include/commons').TOPIC_STATUS;
const SESSION_TYPES = require('../../include/commons').SESSION_TYPES;

class Topics extends RedisModel {
    constructor() {
        super();
    }

    getTopics(user,status,sessionType){
        let self = this;
        let session = new Sessions();
        if(!sessionType) sessionType = SESSION_TYPES.MUC;
        SessionRepo.findAllByType(user,sessionType,function(err,res){
            if(err){
                ModelUtil.emitError(self.eventEmitter, "获取列表失败"+err);
            }else if(res&&res.length==0){
                ModelUtil.emitOK(self.eventEmitter, []);
            }
            var sessionIds=[];
            for(var j in res){
                sessionIds.push(res[j].id);
            }
            var test = new Map();
            TopicsRepo.findAllBySessionIdsAndStatus(sessionIds,status,function(err,res){
                if(err){
                    ModelUtil.emitError(self.eventEmitter, "获取列表失败"+err);
                }
                else if(res&&res.length==0){
                    ModelUtil.emitOK(self.eventEmitter, []);
                }else{
                    for(var j = 0;j<res.length;j++){
                        callAmount(j,res,res[j]);
                    }
                }

                function callAmount(i,res,r){
                    session.getSessionUnreadMessageCount(res[i].session_id,user,function(err,msgcount){
                        if(err){
                            log.error("getSessionUnreadMessageCount is error:"+err);
                            ModelUtil.emitError(self.eventEmitter, "获取未读消息失败！"+err);
                        }else{
                            callGetImg(i,res,r,msgcount);
                        }
                    })
                }

                var result =[];
                function callGetImg(i,res,r,msgcount){
                    ParticipantRepo.findAll(res[i].session_id,function(err,p){
                        if(err){
                              log.error("获取头像失败:"+err);
                        }else{
                            r.create_time =   r.create_time.getTime();
                            for(var j in p){
                                if(p[j].is_patient){
                                    r.avatar = p[j].avatar;
                                    r.patient = p[j].id;
                                    r.patient_name = p[j].name;
                                    if(r.status!=TOPIC_STATUS.ENDED){
                                        r.msg_count = msgcount;
                                    }
                                }
                            }
                            result.push(r);
                            if(result.length==res.length){
                                ModelUtil.emitOK(self.eventEmitter, res);
                            }
                        }
                    })
                }
            })
        })
    }

    /**
     * 根据topicId获取对应的消息
     * @param topicId
     */
    getTopicMessages(topicId) {
        let self = this;
        let topicKey = RedisModel.makeRedisKey(REDIS_KEYS.Topic, topicId);
        redis.hgetallAsync(topicKey).then(function (topic) {
            let message_time_key = RedisModel.makeRedisKey(REDIS_KEYS.MessagesByTimestamp, topic.session_id);
            let message_key = RedisModel.makeRedisKey(REDIS_KEYS.Messages, topic.session_id);

            //倒序取出所有的消息ID
            let createTime = topic.create_time;
            let endTime = topic.end_time;
            if (!endTime) {
                endTime = new Date().getTime();
            }

            redis.zrevrangebyscoreAsync(message_time_key, endTime, createTime).then(function (messages) {
                redis.hmgetAsync(message_key, messages).then(function (res) {
                    ModelUtil.emitOK(self.eventEmitter, res);
                });
            })
        })
    }

    /**
     * 创建议题。
     *
     * @param topicName 发起议题的名称
     * @param topicId
     * @param sessionId
     * @param users 发起议题的患者，格式：{"userId1:role", "userId2:role"}
     * @param messages 发送的消息对象，格式：{description:"",title:"",img:"image1,image2",senderId:"",senderName:""}，多个图片用逗号隔开
     */
    createTopic(topicName, topicId, sessionId, users, messages,sessionType) {
        let self = this;
        //MUC模式中sessionID就是患者ID

        let topic_key = RedisModel.makeRedisKey(REDIS_KEYS.Topic, topicId);
        let sessions = new Sessions();
        let participants = new Participants();

        //从数据库中获取sessionId
        let date = new Date();
        var pars = [];
        participants.getMucSessionIdByParticipants(users, function (err, res) {
            if(!err){
                if(res&&res.length>0){
                    sessionId = res[0].id;
                }
                let topics_key = RedisModel.makeRedisKey(REDIS_KEYS.Topics, sessionId);
                redis.zaddAsync(topics_key, date.getTime(), topicId).then(function (res) {
                    redis.hmsetAsync(topic_key,
                        "name", topicName,
                        "end_by", "",
                        "session_id", sessionId,
                        "create_time", date.getTime(),
                        "end_time", "",
                        "description", messages.description,
                        "status", TOPIC_STATUS.NEW)
                        .then(function (res) {

                        })
                }).catch();
            }
            // 已经存在对应的会话更新全科为旁听
            if (res && res.length > 0) {
                for (var j in users) {
                    participants.updateUser(sessionId, j, users[j]);
                }
                callbegin();
            } else {
                // 不存在创建SESSION
                for (var j in users) {
                    pars.push(j + ":" + users[j]);
                }
                sessions.createSession(sessionId, messages.senderName, sessionType, pars, function (res) {
                    if (res) {
                        callbegin();
                    }
                });
            }
        })

        /**
         * 开始消息发送
         */
        function callbegin() {
            let msg = {};
            msg.sender_id = messages.senderId;
            msg.sender_name = messages.senderName;
            msg.content_type = 6;
            msg.content = "开始咨询";
            msg.timestamp = date;
            sessions.saveMessageByTopic(msg, sessionId, function (err, msgId) {
                if (err) {
                    ModelUtil.emitOK(self.eventEmitter, err);
                } else {
                    self.saveTopicToMySQL(topicName, topicId, sessionId, msgId, date, messages.description, TOPIC_STATUS.NEW);
                    callBeginMsg(msgId);
                }
            })
        }

        /**
         * 发送求助内容
         */
        function callBeginMsg(startMsgId) {
            let msg = {};
            msg.sender_id = messages.senderId;
            msg.sender_name = messages.senderName;
            msg.content_type = 1;
            msg.content = messages.description;
            msg.timestamp = new Date();
            sessions.saveMessageByTopic(msg, sessionId, function (err, msgId) {
                log.info("begin send " + messages.description);
            });

            if (messages.img) {
                let imgs = messages.img.split(",");
                for (var j in imgs) {
                    let msgimg = {};
                    msgimg.sender_id = messages.senderId;
                    msgimg.sender_name = messages.senderName;
                    msgimg.content_type = 2;
                    msgimg.content = imgs[j];
                    msgimg.timestamp = new Date();
                    sessions.saveMessageByTopic(msgimg, sessionId, function (err, msgId) {
                        log.info("begin send" + imgs[j]);
                    })
                }
            }

            ModelUtil.emitOK(self.eventEmitter, {"id": startMsgId});
        }
    }

    saveTopicToMySQL(topicName, topicId, sessionId, messageId, date, description,status) {
        TopicsRepo.saveTopic(topicName, topicId, sessionId, messageId, date, description,status);
    }

    /**
     * 议题是否已结束。
     *
     * @param sessionId
     * @param topicId
     * @param handler
     */
    isTopicEnded(sessionId, topicId, handler) {
        let self = this;

        if (topicId === "current") {
            TopicsRepo.findLastTopicStatus(sessionId, callback);
        } else {
            TopicsRepo.findTopicStatus(topicId, callback);
        }

        function callback(err, res) {
            if (err) {
                handler != null ? handler(err, res) : ModelUtil.emitError(self.eventEmitter, err);
            } else {
                if (null == res) {
                    handler != null ? handler(err, res) : ModelUtil.emitDataNotFound(self.eventEmitter, "Topic not found.");
                } else {
                    let ended = res[0].status == TOPIC_STATUS.ENDED;
                    handler != null ? handler(err, res) : ModelUtil.emitOK(self.eventEmitter, ended);
                }
            }
        }
    }

    /**
     * 结束议题
     * @param topicId
     * @param endUser
     * @param endUserName
     */
    endTopic(topicId, endUser, endUserName) {
        let endDate = new Date();
        let self = this;
        let topic_key = RedisModel.makeRedisKey(REDIS_KEYS.Topic, topicId);
        redis.hmsetAsync(topic_key, "end_time", endDate.getTime(), "end_by", endUser, "status", TOPIC_STATUS.ENDED).then(function (res) {
            redis.hgetallAsync(topic_key).then(function (topic) {
                callEnd(topic.session_id);
            })
        });

        /**
         * 结束消息发送
         */
        function callEnd(sessionId) {
            let msg = {
                sender_id: endUser,
                sender_name: endUserName,
                content_type: 7,
                content: endUserName + "结束了咨询",
                timestamp: new Date()
            };

            let sessions = new Sessions();
            sessions.saveMessageByTopic(msg, sessionId, function (err, msgId) {
                if (err) {
                    ModelUtil.emitOK(self.eventEmitter, err);
                } else {
                    ModelUtil.emitOK(self.eventEmitter, {"id": msgId});
                    TopicsRepo.endTopic(topicId, endUser, msg.date, msgId,TOPIC_STATUS.ENDED);
                }
            })
        }
    }

    updateTopic(topicId, valueJson) {
        let topickey = RedisModel.makeRedisKey(REDIS_KEYS.Topic, topicId);
        var dataArray = [];
        for (var j in valueJson) {
            dataArray.push(j);
            dataArray.push(valueJson[j]);
        }

        redis.hmsetAsync(topickey, dataArray).then(function (res) {
        });

        TopicsRepo.updateTopics(topicId, valueJson);
    }
}

// Expose class
module.exports = Topics;