编写用户登录会话缓存;格式化session.js代码

src/server/models/sessions/sessions.js

@@ -9,7 +9,7 @@ let redis = redisClient.connection;
let RedisModel = require('./../redis.model.js');
let modelUtil = require('../../util/model.util');
let Messages = require('../messages/messages');
let Participants = require('./Participants')
let Participants = require('./Participants');
let log = require('../../util/log.js');
const RedisKeys = require('../../include/commons').REDIS_KEYS;
const Commons = require('../../include/commons');
@@ -28,8 +28,8 @@ class Sessions extends RedisModel {
     * @param userId
     * @param handler
     */
    getUserSessionsFromMysql(userId,handler){
        SessionRepo.getUserSessionsFromMysql(userId,handler);
    getUserSessionsFromMysql(userId, handler) {
        SessionRepo.getUserSessionsFromMysql(userId, handler);
    }
    /**
@@ -37,42 +37,43 @@ class Sessions extends RedisModel {
     * @param sessionId
     * @param handler
     */
    getSessions(sessionId,handler){
        SessionRepo.getSessions(sessionId,handler);
    getSessions(sessionId, handler) {
        SessionRepo.getSessions(sessionId, handler);
    }
    /**
     * 根据用户ID获取用户的session列表
     * @param userId
     */
    getUserSessions(userId,page,pagesize){
        let user_session_key =  super.makeRedisKey(RedisKeys.UserSessions,userId);
    getUserSessions(userId, page, pagesize) {
        let user_session_key = super.makeRedisKey(RedisKeys.UserSessions, userId);
        let self = this;
        let _super = super.makeRedisKey;
        if(page >0){
            page = page*pagesize;
            pagesize = pagesize+page;
        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);
        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);
            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){
                    redis.zscoreAsync(participants_key, userId).then(function (restimestamp) {
                        //时间差获取消息数量
                        callamount(res,j,_len,session,restimestamp);
                        callamount(res, j, _len, session, restimestamp);
                    })
                }).catch(function(err){
                }).catch(function (err) {
                    throw err;
                })
            }
@@ -85,13 +86,13 @@ class Sessions extends RedisModel {
             * @param session 当前会话
             * @param restimestamp 当前会话当前用户的最后一次时间搓
             */
            function callamount(res,j,_len,session,restimestamp){
                let message_time_key = _super(RedisKeys.MessagesByTimestamp,session);
                redis.zrangebyscoreAsync(message_time_key,restimestamp,(new Date().getTime())).then(function(messagetimelist){
            function callamount(res, j, _len, session, restimestamp) {
                let message_time_key = _super(RedisKeys.MessagesByTimestamp, 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){
                    callback(res, j, _len);
                }).catch(function (err) {
                    throw err;
                })
            }
@@ -102,14 +103,14 @@ class Sessions extends RedisModel {
             * @param j
             * @param _len
             */
            function callback(res,j,_len){
            function callback(res, j, _len) {
                sessionlist.push(res);
                if(j==(_len-1)){
                    modelUtil.emitData(self.eventEmitter,{"status":200,"data":sessionlist});
                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);
        }).catch(function (res) {
            modelUtil.emitData(self.eventEmitter, "get list error " + res + ",user:" + userId);
        })
    }
@@ -120,55 +121,55 @@ class Sessions extends RedisModel {
     * @param page 第几页
     * @param pagesize 分页数量
     */
    getSessionMessages(sessionId,user,page,pagesize){
    getSessionMessages(sessionId, user, page, pagesize) {
        let self = this;
        let message_timestamp_key = super.makeRedisKey(RedisKeys.MessagesByTimestamp,sessionId);
        let message_key = super.makeRedisKey(RedisKeys.Messages,sessionId);
        let participants_key = super.makeRedisKey(RedisKeys.Participants,sessionId);
        let message_timestamp_key = super.makeRedisKey(RedisKeys.MessagesByTimestamp, sessionId);
        let message_key = super.makeRedisKey(RedisKeys.Messages, sessionId);
        let participants_key = super.makeRedisKey(RedisKeys.Participants, sessionId);
        //超过最大限制后从mysql获取数据
        if(page*pagesize>=config.sessionConfig.maxMessageCount){
        if (page * pagesize >= config.sessionConfig.maxMessageCount) {
            let message = new Messages();
            message.getMessageByPage(sessionId,page,pagesize,function(err,res){
                if(!err){
                      modelUtil.emitData(self.eventEmitter,{"status":200,"data":res});
                }else{
                    modelUtil.emitData(self.eventEmitter,{"status":-1,"data":err});
            message.getMessageByPage(sessionId, page, pagesize, function (err, res) {
                if (!err) {
                    modelUtil.emitData(self.eventEmitter, {"status": 200, "data": res});
                } else {
                    modelUtil.emitData(self.eventEmitter, {"status": -1, "data": err});
                }
            })
        }else{
            if(page>0){
                page = page*pagesize;
                pagesize = pagesize+page;
        } else {
            if (page > 0) {
                page = page * pagesize;
                pagesize = pagesize + page;
            }
            let participants = new Participants();
            participants.existsUser(sessionId,user,function(res){
                if(!res){
                    modelUtil.emitData(self.eventEmitter,{"status":-1,"msg":"用户不在此会话中！"});
                }else{
            participants.existsUser(sessionId, user, function (res) {
                if (!res) {
                    modelUtil.emitData(self.eventEmitter, {"status": -1, "msg": "用户不在此会话中！"});
                } else {
                    //倒序取出最后N条消息
                    redis.zrevrangeAsync(message_timestamp_key,page,pagesize).then(function(res){
                    redis.zrevrangeAsync(message_timestamp_key, page, pagesize).then(function (res) {
                        //取出消息实体
                        if(res.length==0){
                            modelUtil.emitData(self.eventEmitter,{"status":200,"data":[]});
                        if (res.length == 0) {
                            modelUtil.emitData(self.eventEmitter, {"status": 200, "data": []});
                            return;
                        }
                        redis.hmgetAsync(message_key,res).then(function(messages) {
                        redis.hmgetAsync(message_key, res).then(function (messages) {
                            console.log(messages)
                            //将取到的消息返回给前端
                            modelUtil.emitData(self.eventEmitter,{"status":200,"data":messages});
                        }).then(function(){
                            modelUtil.emitData(self.eventEmitter, {"status": 200, "data": messages});
                        }).then(function () {
                            //更新患者最后一次获取消息的日期
                            redis.zaddAsync(participants_key, (new Date().getTime()),user).then(function(res){
                            redis.zaddAsync(participants_key, (new Date().getTime()), user).then(function (res) {
                                console.log(res);
                            }).catch(function(res){
                            }).catch(function (res) {
                                throw res;
                            })
                        })
                    }).catch(function(res){
                        modelUtil.emitData(self.eventEmitter,{"status":-1,"msg":res});
                    }).catch(function (res) {
                        modelUtil.emitData(self.eventEmitter, {"status": -1, "msg": res});
                    })
                }
             })
            })
        }
    }
@@ -180,15 +181,15 @@ class Sessions extends RedisModel {
     * @param message
     * @returns {*}
     */
    updateLastContent(session_key,session_type,name,message){
    updateLastContent(session_key, session_type, name, message) {
        return redis.hmsetAsync(session_key,
            "create_date", message.timestamp,
            "last_content", message.content,
            "last_content_type", message.contentType,
            "type", session_type,
            "senderId",message.senderId,
            "senderName",message.senderName,
            "name",name
            "senderId", message.senderId,
            "senderName", message.senderName,
            "name", name
        );
    }
@@ -197,41 +198,41 @@ class Sessions extends RedisModel {
     * @param message
     * @param sessionId
     */
    saveMessageBySession(message,sessionId) {
    saveMessageBySession(message, sessionId) {
        let self = this;
        let messages = new Messages();
        let participants = new Participants();
        let session_key = super.makeRedisKey(RedisKeys.Session,sessionId);
        let session_key = super.makeRedisKey(RedisKeys.Session, sessionId);
        let message_id = mongoose.Types.ObjectId().toString();
        let session_type = 0;
        let name = "";
        participants.existsUser(sessionId,messages.senderId,function(res){
        participants.existsUser(sessionId, messages.senderId, function (res) {
            //校验发送成员是都在讨论组
            if(res){
                redis.hmgetAsync(session_key, ["type","name"]).then(function(res){
            if (res) {
                redis.hmgetAsync(session_key, ["type", "name"]).then(function (res) {
                    session_type = res[0];
                    name  = res[1];
                    if(!session_type||!name){
                        log.error("session is error for key "+session_key);
                    name = res[1];
                    if (!session_type || !name) {
                        log.error("session is error for key " + session_key);
                        throw "session is not found";
                    }
                }).then(function(res){
                }).then(function (res) {
                    //更新消息相关
                    return  messages.saveMessageForRedis(message_id,sessionId,message);
                    return messages.saveMessageForRedis(message_id, sessionId, message);
                }).then(function (res) {
                    //更新session的最后一条聊天记录
                    return self.updateLastContent(session_key,session_type,name,message);
                    return self.updateLastContent(session_key, session_type, name, message);
                }).then(function (res) {
                    //操作mysql数据库
                    messages.saveMessageForMysql(message,session_type,message_id,sessionId);
                    messages.saveMessageForMysql(message, session_type, message_id, sessionId);
                    //返回数据给前端。
                    modelUtil.emitData(self.eventEmitter, {"status":200,"msg":"发送成功！"});
                    modelUtil.emitData(self.eventEmitter, {"status": 200, "msg": "发送成功！"});
                    //消息推送
                }).catch(function (res) {
                    modelUtil.emitData(self.eventEmitter,{"status":-1,"msg":res});
                    modelUtil.emitData(self.eventEmitter, {"status": -1, "msg": res});
                })
            }else{
                modelUtil.emitData(self.eventEmitter,{"status":-1,"msg":"用户不在此会话当中！"});
            } else {
                modelUtil.emitData(self.eventEmitter, {"status": -1, "msg": "用户不在此会话当中！"});
            }
        })
    }
@@ -243,30 +244,30 @@ class Sessions extends RedisModel {
     * @param type 会话类型
     * @param users 会话成员
     */
    createSessions(sessionId,name,type,users){
        if(type==2){
    createSessions(sessionId, name, type, users) {
        if (type == 2) {
        }
        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(","));
        let session_key = super.makeRedisKey(RedisKeys.Session, sessionId);
        let participants = new Participants();
        // 将session加入redis
        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);
                participants.createParticipantsToMysql(sessionId, users.split(",")); //创建session成员到数据库
            }
        })
    }
@@ -278,38 +279,38 @@ class Sessions extends RedisModel {
     * @param type
     * @param createDate
     */
    saveSessionToMysql(sessionId,name,type,createDate){
        SessionRepo.saveSessionToMysql(sessionId,name,type,createDate);
    saveSessionToMysql(sessionId, name, type, createDate) {
        SessionRepo.saveSessionToMysql(sessionId, name, type, createDate);
    }
    /**
     *置顶操作
     */
    stickSession(sessionId,user){
        let user_session_key = super.makeRedisKey(RedisKeys.UserSessions,user);
    stickSession(sessionId, user) {
        let user_session_key = super.makeRedisKey(RedisKeys.UserSessions, user);
        let self = this;
        //取出最大的session
        redis.zrevrangeAsync(user_session_key,0,0).then(function(res){
        redis.zrevrangeAsync(user_session_key, 0, 0).then(function (res) {
            //获取该session的时间搓
            redis.zscoreAsync(user_session_key,res).then(function(scoreres){
            redis.zscoreAsync(user_session_key, res).then(function (scoreres) {
                let nowtime = new Date().getTime();
                //当前时间搓比redis的时间搓更早证明没有置顶过
                if(scoreres<=nowtime){
                if (scoreres <= nowtime) {
                    //初始化置顶
                   redis.zaddAsync(user_session_key, Commons.STICK_NUM,sessionId).then(function(res){
                       log.info("stickSession:"+sessionId+",res:"+res);
                       modelUtil.emitData(self.eventEmitter,{"status":200,"msg":"置顶成功！"});
                   }).then(function(){
                       SessionRepo.stickSession(sessionId,user,Commons.STICK_NUM);
                   })
                }else{
                    redis.zaddAsync(user_session_key, Commons.STICK_NUM, sessionId).then(function (res) {
                        log.info("stickSession:" + sessionId + ",res:" + res);
                        modelUtil.emitData(self.eventEmitter, {"status": 200, "msg": "置顶成功！"});
                    }).then(function () {
                        SessionRepo.stickSession(sessionId, user, Commons.STICK_NUM);
                    })
                } else {
                    //已有置顶的数据，取出来加1保存回去
                    scoreres =  Number(scoreres)+1;
                    redis.zaddAsync(user_session_key, scoreres,sessionId).then(function(){
                        log.info("stickSession:"+sessionId+",res:"+res);
                        modelUtil.emitData(self.eventEmitter,{"status":200,"msg":"置顶成功！"});
                    }).then(function(){
                        SessionRepo.stickSession(sessionId,user,scoreres);
                    scoreres = Number(scoreres) + 1;
                    redis.zaddAsync(user_session_key, scoreres, sessionId).then(function () {
                        log.info("stickSession:" + sessionId + ",res:" + res);
                        modelUtil.emitData(self.eventEmitter, {"status": 200, "msg": "置顶成功！"});
                    }).then(function () {
                        SessionRepo.stickSession(sessionId, user, scoreres);
                    })
                }
            })
@@ -319,23 +320,22 @@ class Sessions extends RedisModel {
    /**
     *取消置顶操作
     */
    cancelStickSession(sessionId,user){
        let user_session_key = super.makeRedisKey(RedisKeys.UserSessions,user);
        let participants_key = super.makeRedisKey(RedisKeys.Participants,sessionId);
    cancelStickSession(sessionId, user) {
        let user_session_key = super.makeRedisKey(RedisKeys.UserSessions, user);
        let participants_key = super.makeRedisKey(RedisKeys.Participants, sessionId);
        let self = this;
        redis.zscoreAsync(participants_key,user).then(function(res){
            if(!res){
        redis.zscoreAsync(participants_key, user).then(function (res) {
            if (!res) {
                res = new Date().getTime();
            }
            redis.zaddAsync(user_session_key, res,sessionId).then(function(res){
                log.info("cancelStickSession:"+sessionId);
                modelUtil.emitData(self.eventEmitter,{"status":200,"msg":"取消置顶成功！"});
            }).then(function(){
                SessionRepo.unstickSession(sessionId,user);
            redis.zaddAsync(user_session_key, res, sessionId).then(function (res) {
                log.info("cancelStickSession:" + sessionId);
                modelUtil.emitData(self.eventEmitter, {"status": 200, "msg": "取消置顶成功！"});
            }).then(function () {
                SessionRepo.unstickSession(sessionId, user);
            });
        })
    }
}
// Expose class

src/server/models/user/users.js

@@ -156,17 +156,18 @@ class Users extends RedisModel {
        let lastLoginTime = new Date();
        async.waterfall([
            // get user info
            // get user info from mysql
            function (callback) {
                self.getUser(userId, function (err, userInfo) {
                    if(userInfo === null){
                        ModelUtil.emitDataNotFound(self, 'User not exists.');
                        return;
                    }
                    callback(null, userInfo);
                })
            },
            // save user info and app status/wechat status
            // cache user info and app/wechat status
            function (userInfo, callback) {
                let multi = redisConn.multi()
                    .zadd(usersKey, lastLoginTime.getMilliseconds(), userId)
@@ -174,11 +175,11 @@ class Users extends RedisModel {
                        'name', userInfo.name, 'role', loginFromApp ? 'doctor' : 'patient');
                if(loginFromApp){
                    // app status
                    // cache app status
                    multi = multi.hmset(userStatusKey, 'platform', platform, 'app_in_bg', false, 'client_id', clientId,
                        'token', token, 'last_login_time', lastLoginTime);
                } else {
                    // wechat status
                    // cache wechat status
                    multi = multi.hmset(userKey, 'open_id', userInfo.open_id);
                }
@@ -186,28 +187,14 @@ class Users extends RedisModel {
                        callback(null);
                    });
            },
            // load sessions
            // cache sessions
            function (callback) {
                /*let sessions = new Sessions();
                sessions.getUserSessionsFromMysql();*/
            }
        ]);
                let sessions = new Sessions();
                sessions.getUserSessionsFromMysql();
        DoctorRepo.deleteToken(token, function (err, result) {
            if (err) {
                ModelUtil.emitDbError(self.eventEmitter, 'Error occurs when user login and delete token', err);
            } else {
                DoctorRepo.login(userId, token, clientId, platform,
                    function (err, result) {
                        if (err) {
                            ModelUtil.emitDbError(self.eventEmitter, 'Error occurs when user login and delete token', err);
                        }
                        let token = new Token(userId, clientId, platform);
                        ModelUtil.emitData(self.eventEmitter, {token: token.value});
                    });
                ModelUtil.emitData(self.eventEmitter, {token: token.value});
            }
        });
        ]);
    }
    logout(userId, outCallback){