im.doctor/src/server/endpoints/v2/session.endpoint.js

/**
 * 会话接口。
 *
 * author: Sand
 * since: 12/15/2016
 */
"use strict";

let express = require('express');
let router = express.Router();

let ObjectUtil = require("../../util/object.util.js");
let ControllerUtil = require('../../util/controller.util');
let Sessions = require('../../models/sessions/sessions');
let Messages = require('../../models/messages/messages');
let Participants = require('../../models/sessions/participants');
let log = require("../../util/log.js");

let clientCache = require('../../models/socket.io/client.cache').clientCache();
const SESSION_TYPES = require('../../include/commons').SESSION_TYPES;
const APIv2 = require('../../include/endpoints').APIv2;

/**
 * 创建会话。对MUC会话而言，需要创建的是议题，如果是第一次创建议题，那应该附带创建会话，而不是直接创建会话。
 *
 * session_type：1表示MUC会话，2表示P2P，3表示群会话，4表示临时讨论组  
 * (咨询类型：1三师咨询，2视频咨询，3图文咨询，4公共咨询，5病友圈 6、患者名医咨询 7医生名医咨询 8续方咨询 9居民直接咨询专科  10医生发起的求助  11上门服务咨询)
 * users 讨论组包含的用户标示
 * sessionId 会话ID
 *
 * 请求URL: /sessions
 * 参数：
 * {
 *  session_id: 会话ID，非必须，仅对群消息使用。
 *  session_type: 会话类型，必须。
 *  session_name: 会话名称,
 *  participants: 此会话的成员列表，格式：["userId1:role", "userId2:role"]，用户的ID及角色。
 * }
 */
router.post("/", function (req, res) {
    let payload = req.body;
    let testing = ObjectUtil.fieldsCheck(payload, 'participants', 'session_name', 'session_type');
    if (!testing.pass) {
        throw testing.message;
    }

    let participants = payload.participants;
    let sessionName = payload.session_name;
    let sessionType = payload.session_type;
    let sessionId = payload.session_id;
    let sessions = new Sessions();
    let participantArray = [];
    log.info("participants: "+participants);
    participants = JSON.parse(participants);

    //获取传入的参与者数组长度
    let participantLength = 0;
    for (let i in participants) {
        participantLength ++;
    }

    for (let j in participants) {
        log.info("aaaa:"+j + ":" + participants[j]);
        if (payload.hasOwnProperty('videoconferencing') && payload.videoconferencing == 1){
            sessions.conversionAarticipant(j, (doctorid) => {
                participantArray.push(doctorid+":"+participants[j])
                //判断数组长度等于传入的长度，则执行创建会话的请求
                if(participantArray.length == participantLength){
                    ControllerUtil.regModelEventHandler(sessions, res);
                    console.log(sessionId, sessionName, sessionType, participantArray);

                    sessions.createSession(sessionId, sessionName, sessionType, participantArray);
                    ///是否视频会议的会话
                    let videoconferencing = false;

                    // participants = JSON.parse(participants);
                    // for (let j in participants) {
                    //     participantArray.push(j + ":" + participants[j]);
                    // }

                    //视频会议的会话 szx add 20181121
                    if (payload.hasOwnProperty('videoconferencing') && payload.videoconferencing == 1){
                        let access_token = "";
                        if(payload.hasOwnProperty("mobile"))access_token = payload.access_token;
                        videoconferencing = true;
                        //发送广播，给相关的与会人员
                        for (let k in participants) {

                            sessions.conversionAarticipant(k, (doctorid) => {
                                let userId = "pcim_"+doctorid;
                                let pc_doctorClient = clientCache.findById(userId);
                                if(pc_doctorClient){
                                    log.info("videoconferencing send to "+userId);

                                    pc_doctorClient.socket.emit("startVideoconference",{"sessionId":sessionId,"user_id":j});
                                }
                                else{
                                    log.info("videoconferencing not find "+userId);
                                }

                            })
                        }
                    }
                }
            })
        }else{
            participantArray.push(j + ":" + participants[j]);
            //判断数组长度等于传入的长度，则执行创建会话的请求
            if(participantArray.length == participantLength){
                ControllerUtil.regModelEventHandler(sessions, res);
                console.log(sessionId, sessionName, sessionType, participantArray);

                sessions.createSession(sessionId, sessionName, sessionType, participantArray);

                ///是否视频会议的会话
                let videoconferencing = false;

                // participants = JSON.parse(participants);
                // for (let j in participants) {
                //     participantArray.push(j + ":" + participants[j]);
                // }

                //视频会议的会话 szx add 20181121
                if (payload.hasOwnProperty('videoconferencing') && payload.videoconferencing == 1){
                    let access_token = "";
                    if(payload.hasOwnProperty("mobile"))access_token = payload.access_token;
                    videoconferencing = true;
                    //发送广播，给相关的与会人员
                    for (let j in participants) {
                        let userId = "pcim_"+j;

                        let pc_doctorClient = clientCache.findById(userId);
                        if(pc_doctorClient){
                            log.info("videoconferencing send to "+userId);
                            pc_doctorClient.socket.emit("startVideoconference",{"sessionId":sessionId,"user_id":j});
                        }
                        else{
                            log.info("videoconferencing not find "+userId);
                        }
                    }
                }
            }
        }
    }



});

/**
 * 获取会话列表
 *
 * 请求URL /sessions?user_id=3121&page=0&size=10
 */
router.get("/", function (req, res) {
    let page = req.query.page;
    let size = req.query.size;
    let userId = req.query.user_id;
    let businessType = req.query.business_type;
    let status = req.query.status;
    let name = req.query.name;
    let search_type = req.query.search_type;//搜索类型 1医生 2患者 3会话名称
    let videoconferencing = req.query.videoconferencing;
    if (!page) {
        throw {httpStatus: 406, message: 'Missing page.'};
    }
    if (!size) {
        throw {httpStatus: 406, message: 'Missing size.'};
    }
    if (!userId) {
        throw {httpStatus: 406, message: 'Missing user.'};
    }

    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);
    //判断是否是中山医院MDT的请求
    if(videoconferencing && videoconferencing == 1){
        sessions.conversionAarticipant(userId, (doctorid) => {
            //传入参数齐全走过滤方法
            if(status&&businessType&&doctorid&&size&&page){
                sessions.getUserStatusSessions(doctorid,status,businessType,name,search_type,page,size);
            }else{
                sessions.getUserSessions(doctorid,name,search_type, page, size, businessType);
            }
        })
    }else{
        //传入参数齐全走过滤方法
        if(status&&businessType&&userId&&size&&page){
            sessions.getUserStatusSessions(userId,status,businessType,name,search_type,page,size);
        }else{
            sessions.getUserSessions(userId,name,search_type, page, size, businessType);
        }
    }
});



router.get("/getOnlineCountByType", function (req, res) {
    let type = req.query.type;
    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);
    sessions.getOnlineCountByType(type)
});

router.get("/getOnlineListByType", function (req, res) {
    let type = req.query.type;
    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);
    sessions.getOnlineListByType(type)
});

router.get("/findByUserIdAndType", function (req, res) {
    let type = req.query.type;
    let userId = req.query.userId;

    if (!type) {
        throw {httpStatus: 406, message: 'Missing type.'};
    }
    if (!userId) {
        throw {httpStatus: 406, message: 'Missing userId.'};
    }

    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);
    sessions.findByUserIdAndType(userId,type)
});

/**
 * 按会话类型获取会话列表
 * 请求URL /sessions/sessionListByType?user_id=3121&page=0&size=10&type=4
 */
router.get(APIv2.Sessions.SessionListByType, function (req, res) {
    let page = req.query.page;
    let size = req.query.size;
    let userId = req.query.user_id;
    let type = req.query.type;
    let status = req.query.status;
    let name = req.query.name;
    let searchType = req.query.search_type;//p2p会话类型 1医生 2患者
    if (!page) {
        throw {httpStatus: 406, message: 'Missing page.'};
    }
    if (!size) {
        throw {httpStatus: 406, message: 'Missing size.'};
    }
    if (!type) {
        throw {httpStatus: 406, message: 'Missing type.'};
    }

    /**
     * userId 为传值时：管理员调度大屏获取im消息
     */
    // if (!userId) {
    //     throw {httpStatus: 406, message: 'Missing user.'};
    // }

    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);
    sessions.getUserSessionsByType(userId,type,page,size,status,name,searchType);
});

router.get(APIv2.Sessions.SessionListByNoParticipant, function (req, res) {
    let page = req.query.page;
    let size = req.query.size;
    let userId = req.query.user_id;
    let type = req.query.type;
    let status = req.query.status;
    if (!page) {
        throw {httpStatus: 406, message: 'Missing page.'};
    }
    if (!size) {
        throw {httpStatus: 406, message: 'Missing size.'};
    }
    if (!type) {
        throw {httpStatus: 406, message: 'Missing type.'};
    }
    if (!userId) {
        throw {httpStatus: 406, message: 'Missing user.'};
    }

    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);
    sessions.getUserSessionsByTypeAndNoParticipant(userId,type,page,size,status);
});

/**
 * 按会话类型获取会话总数
 * 请求URL /sessions/sessionCountByType?user_id=3121&type=4
 */
router.get(APIv2.Sessions.SessionCountByType, function (req, res) {
    let userId = req.query.user_id;
    let type = req.query.type;
    let status = req.query.status;
    if (!type) {
        throw {httpStatus: 406, message: 'Missing type.'};
    }
    if (!userId) {
        throw {httpStatus: 406, message: 'Missing user.'};
    }

    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);
    sessions.getSessionCountByType(userId,type,status);
});


router.get(APIv2.Sessions.Session,function(req,res){
    let sessionId = req.params.session_id;
    let userId = req.query.user_id;
    if (!sessionId) {
        throw {httpStatus: 406, message: 'Missing sessionId.'};
    }
    if (!userId) {
        throw {httpStatus: 406, message: 'Missing user.'};
    }
    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);
    sessions.getSession(sessionId,userId);
});

/**
 * 最近会话列表。
 *
 * URL:
 *  /sessions/recent?user_id=abc&date_span=7
 */
router.get(APIv2.Sessions.RecentSessions, function (req, res) {
    ControllerUtil.checkRequestQueryParams(req, ['user_id', 'date_span']);

    let userId = req.query.user_id;
    let dateSpan = req.query.date_span;

    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);

    sessions.getRecentSessions(userId, dateSpan);
});

/**
 * 判断会话是否存在。
 *
 * URL:
 *  /sessions/isExist?session_id=abc
 */
router.get(APIv2.Sessions.IsExist, function (req, res) {
    let sessionId = req.query.session_id;
    if (!sessionId) {
        throw {httpStatus: 406, message: 'Missing sessionId.'}
    }
    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);

    sessions.isExist(sessionId);
});

/**
 * 某个聊天记录置顶操作
 *
 * 请求URL /stick?user=3121&sessionId=testsessionmsg1
 */
router.post(APIv2.Sessions.SessionSticky, function (req, res) {
    let user = req.query.user;
    let sessionId = req.query.sessionId;
    if (!user) {
        throw {httpStatus: 406, message: 'Missing user.'};
    }
    if (!sessionId) {
        throw {httpStatus: 406, message: 'Missing sessionId.'};
    }
    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);
    sessions.stickSession(sessionId, user);
});


/**
 * 某个聊天记录置顶操作
 *
 * 请求URL /status?status=1&sessionId=testsessionmsg1
 */
router.post(APIv2.Sessions.SessionStatus, function (req, res) {
    let sessionId = req.query.sessionId;
    let status = req.query.status;
    if (!sessionId) {
        throw {httpStatus: 406, message: 'Missing sessionId.'};
    }
    if (!status) {
        throw {httpStatus: 406, message: 'Missing status.'};
    }
    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);
    sessions.updateSessionStatus(sessionId, status);
});

/**
 * 修改会话名称（修改redis和数据库）
 *
 * 请求URL /name?name=哈哈&sessionId=testsessionmsg1
 */
router.post(APIv2.Sessions.SessionName, function (req, res) {
    let sessionId = req.body.sessionId;
    let name = req.body.name;
    if (!sessionId) {
        throw {httpStatus: 406, message: 'Missing sessionId.'};
    }
    if (!name) {
        throw {httpStatus: 406, message: 'Missing name.'};
    }
    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);
    sessions.updateSessionName(sessionId, name);
});


/**
 * 取消置顶
 * 请求URL /cancelStick?user=3121&sessionId=testsessionmsg1
 */
router.delete(APIv2.Sessions.SessionSticky, function (req, res) {
    let user = req.query.user;
    let sessionId = req.query.sessionId;
    if (!user) {
        throw {httpStatus: 406, message: 'Missing user.'};
    }
    if (!sessionId) {
        throw {httpStatus: 406, message: 'Missing sessionId.'};
    }

    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);

    sessions.cancelStickSession(sessionId, user);
});

/**
 * 获取会话成员。
 */
router.get(APIv2.Sessions.Participants, function (req, res) {
    let sessionId = req.params.session_id;

    let participants = new Participants();
    ControllerUtil.regModelEventHandler(participants, res);

    participants.getParticipants(sessionId);
});

/**
 * 获取会话成员头像列表。
 */
router.get(APIv2.Sessions.ParticipantsAvatar, function (req, res) {
    let sessionId = req.params.session_id;

    let participants = new Participants();
    ControllerUtil.regModelEventHandler(participants, res);
    participants.getParticipantsAvatar(sessionId);
});

/**
 * 增加成员
 * user:增加的人员
 * sessionId 会话ID
 */
router.put(APIv2.Sessions.Participant, function (req, res) {
    let user = req.params.participant_id;
    if (!user) {
        throw {httpStatus: 406, message: 'Missing participant_id.'};
    }

    let sessionId = req.params.session_id;
    if (!sessionId) {
        throw {httpStatus: 406, message: 'Missing session_id.'};
    }

    let participants = new Participants();

    ControllerUtil.regModelEventHandler(participants, res);
    participants.addUser(sessionId, user);
});


/**
 * 增加成员
 * user_id:增加的人员
 * old_user_id:删除的人员
 * session_id 会话ID
 */
router.post(APIv2.Sessions.ParticipantUpdate, function (req, res) {
    let payload = req.body;
    let testing = ObjectUtil.fieldsCheck(payload, 'user_id', 'session_id');
    if (!testing.pass) {
        throw testing.message;
    }
    let participants = new Participants();
    ControllerUtil.regModelEventHandler(participants, res);
    participants.updateSessionUser(payload.user_id, payload.old_user_id, payload.session_id);
});

/**
 * 增加活跃成员
 * user_id:增加的人员
 * old_user_id:删除的人员
 * session_id 会话ID
 */
router.post(APIv2.Sessions.ParticipantUpdateNew, function (req, res) {
    let payload = req.body;
    let testing = ObjectUtil.fieldsCheck(payload, 'user_id', 'session_id');
    if (!testing.pass) {
        throw testing.message;
    }
    let participants = new Participants();
    ControllerUtil.regModelEventHandler(participants, res);
    participants.updateSessionUser0(payload.user_id, payload.old_user_id, payload.session_id);
});


/**
 * 移除成员
 * user:移除的人员
 * sessionId 会话ID
 */
router.delete(APIv2.Sessions.Participant, function (req, res) {
    let user = req.params.participant_id;
    if (!user) {
        throw {httpStatus: 406, message: 'Missing user.'};
    }
    let sessionId = req.params.session_id;
    if (!sessionId) {
        throw {httpStatus: 406, message: 'Missing sessionId.'};
    }

    let participants = new Participants();

    ControllerUtil.regModelEventHandler(participants, res);
    participants.removeUser(sessionId, user);
});

/**
 * 发送消息
 *
 * 请求URL:
 *  /sessions/:session_id/messages
 *
 * 消息体：
 *  {
 *      sender_id: bea851fc,
 *      sender_name: 李毅,
 *      content_type: 1,
 *      content: 李医生，你好
 *  }
 */
router.post(APIv2.Sessions.Messages, function (req, res) {
    let payload = req.body;
    let testing = ObjectUtil.fieldsCheck(payload, "sender_id", "sender_name", "content_type", "content");
    if (!testing.pass) {
        throw {httpStatus: 406, message: testing.message}
    }
    if(payload.view&&payload.view==1){
        throw {httpStatus: 406, message: "观察者模式,不能发送消息！"};
    }
    // 消息的发送时间由服务端决定
    payload.timestamp = new Date((new Date().getTime()));

    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);

    log.info("入参"+payload);

    sessions.saveMessageBySession(req.params.session_id, payload);
});

router.post(APIv2.Sessions.TopicMessages, function (req, res) {
    let payload = req.body;
    let testing = ObjectUtil.fieldsCheck(payload, "sender_id", "sender_name", "content_type", "content");
    if (!testing.pass) {
        throw {httpStatus: 406, message: testing.message}
    }
    if(payload.view&&payload.view==1){
        throw {httpStatus: 406, message: "观察者模式,不能发送消息！"};
    }
    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);
    payload.timestamp = new Date((new Date().getTime()));
    sessions.sendTopicMessages(req.params.topic_id, payload);
})

/**
 * 获取消息
 *
 * 请求URL:
 *  /sessions/:session_id/messages?session_id=blabla&user_id=abc&start_message_id=100&end_message_id=20
 */
router.get(APIv2.Sessions.Messages, function (req, res) {
    let startMsgId = req.query.start_msg_id;
    let endMsgId = req.query.end_msg_id;
    let pagesize = req.query.pagesize;
    let page = req.query.page;
    let user = req.query.user;
    let sessionId = req.query.session_id;
    let content_type = req.query.content_type;
    let isoffset = req.query.isoffset;
    let type = req.query.type;//类型 1获取消息时医生不在session内要自动加入会话
    if (!user) {
        throw {httpStatus: 406, message: 'Missing user.'};
    }
    if (!sessionId) {
        throw {httpStatus: 406, message: 'Missing session_id.'};
    }
    if (!pagesize) {
        pagesize = 20;
    }
    if (!page) {
        page = 1;
    }
    if (content_type) {
        let messages = new Messages();
        ControllerUtil.regModelEventHandler(messages, res);
        messages.getMessageByType(sessionId, page, pagesize, content_type)
    } else {
        let sessions = new Sessions();
        ControllerUtil.regModelEventHandler(sessions, res);

        sessions.getMessages(sessionId, user, startMsgId, endMsgId, page, pagesize, isoffset,type);
    }

});

/**
 * 修改单条消息
 * session_id 会话ID
 * message_id:消息ID
 * content 消息内容
 */
router.post(APIv2.Sessions.MessageUpdate, function (req, res) {
    let payload = req.body;
    let testing = ObjectUtil.fieldsCheck(payload,'session_type', 'session_id','message_id','content');
    if (!testing.pass) {
        throw testing.message;
    }
    let messages = new Messages();
    ControllerUtil.regModelEventHandler(messages, res);
    messages.updateMsgContent(payload.session_type, payload.session_id,payload.message_id, payload.content);
});


router.get(APIv2.Sessions.SessionUnreadMessages, function (req, res) {
    let sessionId = req.params.session_id;
    let userId = req.query.user_id;

    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);

    sessions.getSessionUnreadMessages(sessionId, userId);
});

/**
 * 获取所有会话未读消息数。
 *
 * 请求URL：/sessions/unread_message_count?user_id=xyz&type=1
 */
router.get(APIv2.Sessions.SessionsUnreadMessageCount, function (req, res) {
    let userId = req.query.user_id;
    let type = req.query.type;

    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);

    sessions.getAllSessionsUnreadMessageCount(userId,type);
});


/**
 * 获取指定会话未读消息数
 *
 * 请求URL
 * /sessions/:session_id/unread_message_count?user_id=xyz
 */
router.get(APIv2.Sessions.SessionUnreadMessageCount, function (req, res) {
    let sessionId = req.params.session_id;
    let userId = req.query.user_id;

    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);

    sessions.getSessionUnreadMessageCount(sessionId, userId);
});


/**
 * 获取所有会话未读消息数。
 *
 * 请求URL：/sessions/unread_message_count?user_id=xyz&type=1
 */
router.get(APIv2.Sessions.SessionsUnreadMessageCountByBussinessType, function (req, res) {
    let userId = req.query.user_id;
    let businessType = req.query.business_type;
    let status= req.query.status

    let sessions = new Sessions();
    ControllerUtil.regModelEventHandler(sessions, res);

    sessions.getAllSessionsUnreadMessageCountByStatus(userId,businessType,status);
});


module.exports = router;