冲突解决

src/server/app.js

@@ -32,6 +32,9 @@ let management = require('./endpoints/management.endpoint');
// handlers
let SocketHandler = require('./handlers/socket.handler');
// schedule
let PushJobLoader = require('./models/schedule/push.job.loader')
// initialize express application
let app = express();
app.set('port', config.serverPort);
@@ -115,12 +118,15 @@ server.on('error', function (error) {
server.on('listening', function onListening() {
    let addr = server.address();
    let bind = typeof addr === 'string' ? 'pipe ' + addr : 'port ' + addr.port;
    log.info("WebSocket listening on ", addr.address, bind);
});
let socketHandler = new SocketHandler(io);
socketHandler.start();
log.info('Starting IM server, version ' + config.version + ', running on port ' + server.address().port + ', ' + new Date().toLocaleString());
log.info('Configuration profile: ' + configFile.split('.')[1]);
log.info('Configuration profile: ' + configFile.split('.')[1]);
var Users =  require('./models/user/users');
let abc = new Users();
abc.isPatientId('not-patient_id');

src/server/endpoints/chats.endpoint.js

@@ -17,6 +17,7 @@ let Patient = require("../models/user/patient");
let Doctor = require('../models/user/doctor');
let Group = require('../models/group');
let Search = require('../models/search');
let Sessions = require('../models/sessions/sessions');
const APIv1 = require('../include/endpoints').APIv1;
const CONTENT_TYPES = require('../include/commons').CONTENT_TYPE;
@@ -65,6 +66,39 @@ router.post(APIv1.Chats.SM, function (req, res) {
    doctor.sendSystemMessage(message);
});
router.get(APIv1.Chats.TEST,function(req,res){
    let test = req.query.test;
    //http://192.168.131.107:3008/api/v1/chats/test?test=1&page=0&pagesize=10&user=3121&sessionId=testsessionmsg1
    if(test==1){
        let page = req.query.page;
        let pagesize = req.query.pagesize;
        let user = req.query.user;
        let sessionId =req.query.sessionId;
        let sessions = new Sessions();
        controllerUtil.regModelEventHandler(sessions, res);
        sessions.getSessionMessages(sessionId,user,page,pagesize);
    }
    //http://192.168.131.107:3008/api/v1/chats/test?test=2&page=0&pagesize=10&user=3121
    if(test==2){
        let sessions = new Sessions();
        let page = req.query.page;
        let pagesize = req.query.pagesize;
        let user = req.query.user;
        controllerUtil.regModelEventHandler(sessions, res);
        sessions.getUserSessions(user,page,pagesize);
    }
    //
    if(test==3){
        let sessions = new Sessions();
        let sessionId = req.query.sessionId;
        let users = req.query.users;
        let name = req.query.name;
        let sessionType = req.query.sessionType;
        sessions.createSessions(sessionId,name,sessionType,users);
    }
})
/**
 * 处理Private消息。处理流程分：
 * 1 解析消息，并保存到数据库

src/server/include/commons.js

@@ -88,6 +88,9 @@ exports.REDIS_KEYS = {
    Users: "users:",
    User: "users:" + REDIS_KEY_REPLACER,
    UserStatus: "users:" + REDIS_KEY_REPLACER + ":status",
    UsersSessions: "users:"+REDIS_KEY_REPLACER+":sessions",
    Participants:"participants:"+REDIS_KEY_REPLACER,
    Sessions: "sessions:",
    Session: "sessions:" + REDIS_KEY_REPLACER,

src/server/include/endpoints.js

@@ -43,7 +43,8 @@ const APIv1 = {
        GMStats: '/gm/statistic',
        //系统消息
        SM: '/sm'
        SM: '/sm',
        TEST:'/test'
    },
    Users: {

src/server/models/messages/messages.js

@@ -5,14 +5,15 @@
let RedisClient = require('../../repository/redis/redis.client.js');
let redisClient = RedisClient.redisClient();
let BaseModel = require('./../base.model.js');
let redis = redisClient.connection;
let RedisModel = require('./../redis.model.js');
let modelUtil = require('../../util/modelUtil');
var imDb = require('../../repository/mysql/db/im.db');
let log = require('../../util/log.js');
const RedisKey = require('../../include/commons').REDIS_KEYS;
const IMTABLE = require('../../include/commons').IM_DB;
class Messages extends BaseModel {
class Messages extends RedisModel {
    constructor() {
        super();
    }
@@ -64,6 +65,17 @@ class Messages extends BaseModel {
    }
    saveMessageForRedis(message_id,sessionId,message){
        let message_key = super.makeRedisKey(RedisKey.Messages,sessionId);
        let message_timestamp_key = super.makeRedisKey(RedisKey.MessagesTimestamp,sessionId);
        redis.hsetAsync(message_key, message_id, JSON.stringify(message)).then(function (res) {
            log.info("success save redis message by session :"+sessionId);
            //保存message_timestamp_key redis
            return redis.zaddAsync(message_timestamp_key, message.timestamp.getTime(), message_id);
        });
    }
    /**
     * 保存Message 到mysql
     * @param messages 消息对象
@@ -77,6 +89,8 @@ class Messages extends BaseModel {
            "handler": function (err, res) {
                if(err) {
                    log.error("sql:"+sql+",error:"+err+",data:"+JSON.stringify(messages)+",messageid:"+messageid+",sessionId:"+sessionId);
                }else{
                    log.info("save message to mysql is success by session :"+sessionId);
                }
            }
        });

src/server/models/sessions/participants.js

@@ -5,12 +5,15 @@
let RedisClient = require('../../repository/redis/redis.client.js');
let redisClient = RedisClient.redisClient();
let BaseModel = require('./../base.model.js');
let redis = redisClient.connection;
let RedisModel = require('./../redis.model.js');
let modelUtil = require('../../util/modelUtil');
const RedisKey = require('../../include/commons').RedisKey;
let imDb = require('../../repository/mysql/db/im.db');
let log = require('../../util/log.js');
const RedisKey = require('../../include/commons').REDIS_KEYS;
const IMTABLE = require('../../include/commons').IM_DB;
class Participants extends BaseModel {
class Participants extends RedisModel {
    constructor() {
        super();
    }
@@ -33,6 +36,77 @@ class Participants extends BaseModel {
    }
    /**
     * 根据医生和患者
     * @param patient
     * @param doctor
     */
    getSessionIdByParticipants(patient,doctor,handler){
        let sql ="select session_id from "+IMTABLE.PARTICIPANTS+" p1 ,participants p2 " +
            "where p1.session_id = p2.session_id and " +
            "((p1.participaint_id = ? and p2.participaint_id = ?) or (p1.participaint_id = ? and p2.participaint_id = ?))"
        imDb.execQuery({
            "sql": sql,
            "args": [patient,doctor,doctor,patient],
            "handler": function (err, res) {
                if(err) {
                    log.error("getSessionIdByParticipants is fail error: "+err);
                }
                handler(err,res);
            }
        });
    }
    createParticipantsToRedis(session_id,users,createDate,handler){
        let participants_key =  super.makeRedisKey(RedisKey.Participants,session_id);
        for(var j in users){
            let user_session_key =  super.makeRedisKey(RedisKey.UsersSessions,users[j]);
            redis.zaddAsync(participants_key, createDate.getTime(),users[j]).then(function(res){
                    return  redis.zaddAsync(user_session_key,createDate.getTime(),session_id);
              }
            ).catch(function(err){
                log.error("createParticipantsToRedis is fail error:"+err+",session_id:"+session_id+",users:"+users.join(","));
                    handler(false);
            });
        }
        handler(true);
    }
    /**
     * mysql成员创建
     * @param users
     */
    createParticipantsToMysql(session_id,users){
        let sql="insert into "+IMTABLE.PARTICIPANTS +" (session_id,participaint_id,participaint_role,receiving) VALUES "
        let args=[];
        for(var j in users){
            sql+="(?,?,?,?),";
            args.push(session_id);
            args.push(users[j]);
            args.push(0);
            args.push(0);
        }
        sql = sql.substring(0,sql.lastIndexOf(","));
        imDb.execQuery({
            "sql": sql,
            "args": args,
            "handler": function (err, res) {
                if(err) {
                    log.error("createParticipantsForMysql is fail error: "+err+",session_id:"+session_id+",users:"+users.join(","));
                }else{
                   return res;
                }
            }
        });
        return true;
    }
    /**
     * MUC成员创建
     * @param users
     */
    createMUCParticipants(users){
        return true;
    }
}

src/server/models/sessions/sessions.js

@@ -6,19 +6,19 @@
let RedisClient = require('../../repository/redis/redis.client.js');
let redisClient = RedisClient.redisClient();
let redis = redisClient.connection;
let BaseModel = require('./../base.model.js');
let RedisModel = require('./../redis.model.js');
let modelUtil = require('../../util/modelUtil');
let Messages = require('../messages/messages');
let Participants = require('./Participants');
let imDb = require('../../repository/mysql/db/im.db');
let log = require('../../util/log.js');
const RedisKeys = require('../../include/commons').REDIS_KEYS;
const IMTABLE = require('../../include/commons').IM_DB;
let mongoose = require('mongoose');
class Sessions extends BaseModel {
class Sessions extends RedisModel {
    constructor() {
        super();
        this._sessions_key = RedisKeys.Sessions;
        this._session_key = RedisKeys.Session;
        this._msg_key = RedisKeys.Messages;
        this._ms_key_timestamp = RedisKeys.MessagesTimestamp;
    }
    /**
@@ -33,25 +33,114 @@ class Sessions extends BaseModel {
     * 根据用户ID获取用户的session列表
     * @param userId
     */
    getUserSessions(userId){
    getUserSessions(userId,page,pagesize){
        let user_session_key =  super.makeRedisKey(RedisKeys.UsersSessions,userId);
        let self = this;
        let _super = super.makeRedisKey;
        if(page >0){
            page = page*pagesize;
            pagesize = pagesize+page;
        }
        //倒序
        redis.zrevrangeAsync(user_session_key,page,pagesize).then(function(res){
            let sessionlist =[];
            if(res.length==0){
                modelUtil.emitData(self.eventEmitter,{"status":200,"data":res});
            }else{
                for(var j in res){
                    calllist(res[j],j,res.length);
                }
            }
            function calllist(session,j,_len){
                let session_key =_super(RedisKeys.Session,session);
                redis.hgetallAsync(session_key).then(function(res){
                    let participants_key = _super(RedisKeys.Participants,session);
                    //当前用户最后一次登录改讨论组时间
                    redis.zscoreAsync(participants_key,userId).then(function(restimestamp){
                        //时间差获取消息数量
                        callamount(res,j,_len,session,restimestamp);
                    })
                }).catch(function(err){
                    throw err;
                })
            }
            /**
             * 消息统计
             * @param res 返回的会话列表
             * @param j 当前会话列表的位置
             * @param _len 列表长度 用做返回前端操作
             * @param session 当前会话
             * @param restimestamp 当前会话当前用户的最后一次时间搓
             */
            function callamount(res,j,_len,session,restimestamp){
                let message_time_key = _super(RedisKeys.MessagesTimestamp,session);
                redis.zrangebyscoreAsync(message_time_key,restimestamp,(new Date().getTime())).then(function(messagetimelist){
                    res.sessionId = session;
                    res.message = messagetimelist.length;
                    callback(res,j,_len);
                }).catch(function(err){
                    throw err;
                })
            }
            /**
             * 列表封装完毕后由此回调返回数据界面
             * @param res
             * @param j
             * @param _len
             */
            function callback(res,j,_len){
                sessionlist.push(res);
                if(j==(_len-1)){
                    modelUtil.emitData(self.eventEmitter,{"status":200,"data":sessionlist});
                }
            }
        }).catch(function(res){
            modelUtil.emitData(self.eventEmitter,"get list error "+res+",user:"+userId);
        })
    }
    /**
     * 根据sessionId获取对应的消息
     * @param sessionId
     * @param sessionId 会话ID
     * @param user 拉取消息的人
     * @param page 第几页
     * @param pagesize 分页数量
     */
    getSessionMessages(sessionId){
        let key = this._msg_key.replace("{key}",sessionId);
        console.log(key);
        redis.zsetAsync(key,{ id: 'kris', password: 'password' }).then(function(res){
            console.log(res);
            redis.hgetallAsync(key).then(function(res){
                console.log(res);
    getSessionMessages(sessionId,user,page,pagesize){
        let self = this;
        let message_timestamp_key = super.makeRedisKey(RedisKeys.MessagesTimestamp,sessionId);
        let message_key = super.makeRedisKey(RedisKeys.Messages,sessionId);
        let participants = super.makeRedisKey(RedisKeys.Participants,sessionId);
        if(page>0){
            page = page*pagesize;
            pagesize = pagesize+page;
        }
        //倒序取出最后N条消息
        redis.zrevrangeAsync(message_timestamp_key,page,pagesize).then(function(res){
            //取出消息实体
            if(res.length==0){
                modelUtil.emitData(self.eventEmitter,{"status":200,"data":[]});
                return;
            }
            redis.hmgetAsync(message_key,res).then(function(messages) {
                console.log(messages)
                //将取到的消息返回给前端
                modelUtil.emitData(self.eventEmitter,{"status":200,"data":messages});
            }).then(function(){
                //更新患者最后一次获取消息的日期
                redis.zaddAsync(participants, (new Date().getTime()),user).then(function(res){
                    console.log(res);
                }).catch(function(res){
                    throw res;
                })
            })
        }).catch(function(res){
            modelUtil.emitData(self.eventEmitter,{"status":-1,"msg":res});
        })
    }
    /**
     * 更新最后一条消息
     * @param session_key rediskey
@@ -80,30 +169,32 @@ class Sessions extends BaseModel {
    saveMessageBySession(message,sessionId) {
        let self = this;
        let message_key = super.makeRedisKey(this._msg_key,sessionId);
        let message_timestamp_key = super.makeRedisKey(this._ms_key_timestamp,sessionId);
        let session_key = super.makeRedisKey(this._session_key,sessionId);
        let session_key = super.makeRedisKey(RedisKeys.Session,sessionId);
        let message_id = mongoose.Types.ObjectId().toString();
        let session_type = 0;
        let name = 0;
        let name = "";
        let messages = new Messages();
        redis.hmgetAsync(session_key, ["type","name"]).then(function(res){
            session_type = res[0];
            name  = res[1];
        }).then(
            redis.hsetAsync(message_key, message_id, JSON.stringify(message))).then(function (res) {
            //保存message_timestamp_key redis
            return redis.zaddAsync(message_timestamp_key, message.timestamp.getTime(), message_id);
            if(!session_type||!name){
                log.error("session is error for key "+session_key);
                throw "session is not found";
            }
        }).then(function(res){
            //更新消息相关
            return  messages.saveMessageForRedis(message_id,sessionId,message);
        }).then(function (res) {
            //更新session的最后一条聊天记录
            return self.updateLastContent(session_key,session_type,name,message);
        }).then(function (res) {
            //操作mysql数据库
            let messages = new Messages();
            messages.saveMessageForMysql(message,session_type,message_id,sessionId);
            //返回数据给前端。
            modelUtil.emitData(self.eventEmitter, "发送成功！");
            modelUtil.emitData(self.eventEmitter, {"status":200,"msg":"发送成功！"});
            //消息推送
        }).catch(function (res) {
            console.log(res);
            modelUtil.emitData(self.eventEmitter,{"status":-1,"msg":res});
        })
    }
@@ -120,6 +211,60 @@ class Sessions extends BaseModel {
    }
    /**
     * 非MUC模式创建会话
     * @param sessionId 会话ID
     * @param name 会话名称
     * @param type 会话类型
     * @param users 会话成员
     */
    createSessions(sessionId,name,type,users){
        let self = this;
        let createDate = new Date();
        let session_key = super.makeRedisKey(RedisKeys.Session,sessionId);
        let participants  = new Participants();
        //将session加入reids
        participants.createParticipantsToRedis(sessionId,users.split(","),createDate,function(res){
            if(!res){
                modelUtil.emitData(self.eventEmitter, {"status":-1,"msg":res});
            }else{
                let messages={};
                messages.senderId="system";
                messages.senderName="系统消息";
                messages.timestamp=createDate;
                messages.content=""
                messages.contentType="1";
                self.updateLastContent(session_key,type,name,messages);
                modelUtil.emitData(self.eventEmitter, {"status":200,"msg":"session create success！"});
                self.saveSessionToMysql(sessionId,name,type,createDate);
                //创建session成员到数据库
                participants.createParticipantsToMysql(sessionId,users.split(","));
            }
        })
    }
    /**
     * 保存session到sql数据库
     * @param sessionId
     * @param name
     * @param type
     * @param createDate
     */
    saveSessionToMysql(sessionId,name,type,createDate){
        let sql ="insert into "+IMTABLE.SESSIONS+" (id,name,type,create_date) VALUES (?,?,?,?) ";
        imDb.execQuery({
            "sql": sql,
            "args": [sessionId,name,type,createDate],
            "handler": function (err, res) {
                if(err) {
                    log.error("sql:"+sql+"data:sessionId："+sessionId+",name："+name+",type："+type+",createDate："+createDate);
                }else{
                    log.info("save session to mysql is success by session :"+sessionId);
                }
            }
        });
    }
}

src/server/models/sessions/topics.js

@@ -5,12 +5,14 @@
let RedisClient = require('../../repository/redis/redis.client.js');
let redisClient = RedisClient.redisClient();
let BaseModel = require('./../base.model.js');
let RedisModel = require('./../redis.model.js');
let modelUtil = require('../../util/modelUtil');
let Participants = require("./participants");
let Sessions = require("./sessions");
const RedisKey = require('../../include/commons').RedisKey;
class Topics extends BaseModel {
class Topics extends RedisModel {
    constructor() {
        super();
    }
@@ -42,6 +44,34 @@ class Topics extends BaseModel {
    }
    /**
     *
     * @param topicName 发起议题的名称
     * @param patient 发起议题的患者
     * @param doctor 参与的医生
     * @param messages 发送的消息对象{quesion:"",img:""}图片多个用逗号隔开
     */
    createTopics(topicName,patient,healthDoctor,doctor,messages){
        let self = this;
        let participants = new Participants();
        let sessions = new Sessions();
        //从数据库中获取sessionId
        participants.getSessionIdByParticipants(patient,healthDoctor,function(err,res){
            if (err) {
                modelUtil.emitDbError(self.eventEmitter, "Get group member's avatar list failed", err);
                return;
            }
            //如果存在的情况直接返回
            if(res){
                return res;
            }else{
            //不存在则去创建一个session
            }
        })
    }
}
// Expose class

src/server/node_modules/getui/node_modules/protobufjs/node_modules/ascli/node_modules/optjs/README.md

@@ -41,4 +41,4 @@ console.log(require("./opt.js")());
License
-------
NASA Open Source Agreement v1.3
MIT