会话模型新增

src/server/include/commons.js

@@ -81,6 +81,23 @@ exports.DEFAULT_PAGE_SIZE = 100;
/**
 * Redis Key列表。
 */
let redis_model_key ="{key}";
exports.REDIS_KEYS = {
  Users: "users:"
};
  Users: "users:",
  Sessions:"sessions:",
  Session:"sessions:"+redis_model_key,
  Messages:"sessions:"+redis_model_key+":messages",
  MessagesTimestamp:"sessions:"+redis_model_key+":messages_by_timestamp",
  Topics:"sessions:"+redis_model_key+":topics",
  Topic:"topics:"+redis_model_key
};
exports.REDIS_MODEL_KEY =redis_model_key;
exports.IM_DB={
    "P2PMSG":"p2p_messages",
    "MUCMSG":"muc_messages",
    "GROUPMSG":"group_messages",
    "PARTICIPANTS":"participants",
    "SESSIONS":"sessions",
    "TOPICS":"topics"
}

src/server/models/messages.js

@@ -1,68 +0,0 @@
/**
 * 消息模型。
 */
"use strict";
let RedisClient = require('../repository/redis/redis.client');
let redisClient = RedisClient.redisClient();
let BaseModel = require('./base.model');
let modelUtil = require('../util/modelUtil');
const PAGE_KEY = require('../include/commons').REDIS_KEY;
class Messages extends BaseModel {
    constructor() {
        super();
    }
    /**
     * 根据topicId获取对应的议题的信息列表
     * @param topicId
     */
    getMessagesByTopicId(topicId){
        
    }
    /**
     * 分页
     * 根据topicId获取对应的议题的成员信息
     * @param topicId
     */
    getMessagesByTopicIdForPage(topicId,page,pagesize){
    }
    /**
     * 根据sessionId获取对应的会话的信息列表
     * @param sessionId
     */
    getMessagesBySession(sessionId){
    }
    /**
     * 分页
     * 根据sessionId获取对应的会话的信息列表
     * @param sessionId
     */
    getMessagesBySessionForPage(sessionId,page,pagesize){
    }
    /**
     * 根据消息ID获取单条消息
     * @param messageId
     */
    getMessagesByid(messageId){
    }
}
// Expose class
module.exports = Messages;

src/server/models/messages/messages.js

@@ -0,0 +1,89 @@
/**
 * 消息模型。
 */
"use strict";
let RedisClient = require('../../repository/redis/redis.client.js');
let redisClient = RedisClient.redisClient();
let BaseModel = require('./../base.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 {
    constructor() {
        super();
    }
    /**
     * 根据topicId获取对应的议题的信息列表
     * @param topicId
     */
    getMessagesByTopicId(topicId){
        
    }
    /**
     * 分页
     * 根据topicId获取对应的议题的成员信息
     * @param topicId
     */
    getMessagesByTopicIdForPage(topicId,page,pagesize){
    }
    /**
     * 根据sessionId获取对应的会话的信息列表
     * @param sessionId
     */
    getMessagesBySession(sessionId){
    }
    /**
     * 分页
     * 根据sessionId获取对应的会话的信息列表
     * @param sessionId
     */
    getMessagesBySessionForPage(sessionId,page,pagesize){
    }
    /**
     * 根据消息ID获取单条消息
     * @param messageId
     */
    getMessagesByid(messageId){
    }
    /**
     * 保存Message 到mysql
     * @param messages 消息对象
     * @type type 会话类型，1表示MUC会话，2表示P2P，3表示群会话，4表示临时讨论组
     */
    saveMessageForMysql(messages,type,messageid,sessionId){
        var sql = "INSERT INTO "+(type==1?IMTABLE.MUCMSG:type==2?IMTABLE.P2PMSG:IMTABLE.GROUPMSG)+" (id, session_id, sender_id, sender_name,content_type, content, timestamp) VALUES (?,?,?,?,?,?,?) ";
        imDb.execQuery({
            "sql": sql,
            "args": [messageid,sessionId,messages.senderId,messages.senderName,messages.contentType,messages.content,messages.timestamp],
            "handler": function (err, res) {
                if(err) {
                    log.error("sql:"+sql+",error:"+err+",data:"+JSON.stringify(messages)+",messageid:"+messageid+",sessionId:"+sessionId);
                }
            }
        });
    }
}
// Expose class
module.exports = Messages;

src/server/models/redis.model.js

@@ -7,35 +7,20 @@
 * since: 2016.12.13
 */
"use strict";
let log = require("../util/log.js");
const RedisKeys = require('../include/commons').REDIS_KEYS;
const RedisSessionKey = require('../include/commons').REDIS_SESSION_KEY;
let sessionKey =RedisSessionKey;
class RedisModel{
const RedisModelKey = require('../include/commons').REDIS_MODEL_KEY;
class RedisModel {
    constructor() {
        this._RedisModelKey= RedisKeys;
        this._setSessionKey = function(key){
            for (let modelKey in RedisKeys){
                let value  =  RedisKeys[modelKey];
                if(value.indexOf(RedisSessionKey)>=0){
                    this._RedisModelKey[modelKey] = value.replace(RedisSessionKey,key);
                }
            }
        };
        //根据redis的key获取单个rediskey的值
        this._getKey = function(redisKey,keyModel,keyValue){
            let _key  = RedisKeys[redisKey];
            if(_key.indexOf(keyModel)>=0){
                _key.replace(keyModel,keyValue);
            }
            return _key;
        }
    }
    get getRedisModelKey(){
        return this._RedisModelKey;
    _getKey(redisKey, keyValue) {
        if (redisKey.indexOf(RedisModelKey) >= 0) {
            return redisKey.replace(RedisModelKey, keyValue);
        }else{
            log.warn("redisModelKey is not found");
            return redisKey;
        }
    }
}
module.exports = RedisModel;

src/server/models/sessions.js

@@ -1,50 +0,0 @@
/**
 * 会话模型。
 */
"use strict";
let RedisClient = require('../repository/redis/redis.client');
let redisClient = RedisClient.redisClient();
let BaseModel = require('./base.model');
let modelUtil = require('../util/modelUtil');
const PAGE_KEY = require('../include/commons').REDIS_KEY;
class Sessions extends BaseModel {
    constructor() {
        super();
    }
    /**
     * 根据sessionId获取对应的Session
     * @param sessionId
     */
    getSessionsById(sessionId){
    }
    /**
     * 根据用户ID获取用户的session列表
     * @param UserId
     */
    getUserSessions(UserId){
    }
    /**
     * 根据sessionId获取对应的消息
     * @param sessionId
     */
    getSessionMessages(sessionId){
    }
}
// Expose class
module.exports = Sessions;

src/server/models/participants.js

@@ -3,11 +3,11 @@
 */
"use strict";
let RedisClient = require('../repository/redis/redis.client');
let RedisClient = require('../../repository/redis/redis.client.js');
let redisClient = RedisClient.redisClient();
let BaseModel = require('./base.model');
let modelUtil = require('../util/modelUtil');
const PAGE_KEY = require('../include/commons').REDIS_KEY;
let BaseModel = require('./../base.model.js');
let modelUtil = require('../../util/modelUtil');
const RedisKey = require('../../include/commons').RedisKey;
class Participants extends BaseModel {

src/server/models/sessions/sessions.js

@@ -0,0 +1,128 @@
/**
 * 会话模型。
 */
"use strict";
let RedisClient = require('../../repository/redis/redis.client.js');
let redisClient = RedisClient.redisClient();
let redis = redisClient.connection;
let BaseModel = require('./../base.model.js');
let modelUtil = require('../../util/modelUtil');
let Messages = require('../messages/messages');
const RedisKeys = require('../../include/commons').REDIS_KEYS;
let mongoose = require('mongoose');
class Sessions extends BaseModel {
    constructor() {
        super();
        this._sessions_key = RedisKeys.Sessions;
        this._session_key = RedisKeys.Session;
        this._msg_key = RedisKeys.Messages;
        this._ms_key_timestamp = RedisKeys.MessagesTimestamp;
    }
    /**
     * 根据sessionId获取对应的Session
     * @param sessionId
     */
    getSessionsById(sessionId){
    }
    /**
     * 根据用户ID获取用户的session列表
     * @param userId
     */
    getUserSessions(userId){
    }
    /**
     * 根据sessionId获取对应的消息
     * @param sessionId
     */
    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);
            })
        })
    }
    /**
     * 更新最后一条消息
     * @param session_key rediskey
     * @param create_date 创建时间
     * @param last_content 最后一条消息内容
     * @param last_content_type 消息类型
     * @param type 会话类型
     * @param sender 发送者ID
     * @param sendername 发送者名字
     * @param name 议题名称
     * @returns {*}
     */
     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
        );
    }
    saveMessageBySession(message,sessionId) {
        let self = this;
        let message_key = super._getKey(this._msg_key,sessionId);
        let message_timestamp_key = super._getKey(this._ms_key_timestamp,sessionId);
        let session_key = super._getKey(this._session_key,sessionId);
        let message_id = mongoose.Types.ObjectId().toString();
        let session_type = 0;
        let name = 0;
        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);
        }).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, "发送成功！");
        }).catch(function (res) {
            console.log(res);
        })
    }
    /**
     * 根据sessionId获取对应的消息
     * @param sessionId
     */
    getSessionMessagesByPage(sessionId,page,pageSize){
    }
}
// Expose class
module.exports = Sessions;

src/server/models/topics.js

@@ -3,11 +3,11 @@
 */
"use strict";
let RedisClient = require('../repository/redis/redis.client');
let RedisClient = require('../../repository/redis/redis.client.js');
let redisClient = RedisClient.redisClient();
let BaseModel = require('./base.model');
let modelUtil = require('../util/modelUtil');
const PAGE_KEY = require('../include/commons').REDIS_KEY;
let BaseModel = require('./../base.model.js');
let modelUtil = require('../../util/modelUtil');
const RedisKey = require('../../include/commons').RedisKey;
class Topics extends BaseModel {

src/server/resources/config/config.dev.js

@@ -15,7 +15,7 @@ let imDbConfig = {
    host: '172.19.103.77',
    user: 'root',
    password: '123456',
    database: 'im_new',
    database: 'ichat',
    connectionLimit: '50',
    charset : 'utf8mb4'
};
@@ -70,7 +70,7 @@ let wechatConfig = {
exports.app = 'IM.Server';
exports.version = '1.2.7';
exports.debug = true;
exports.serverPort = 3000;
exports.serverPort = 3008;
exports.sessionExpire = 1800;
exports.showSQL = true;