rt-sim-training-client/src/store/modules/socket.js

import store from '@/store/index_APP_TARGET';
import { Notification } from 'element-ui';

function handle(state, data) {
    // console.log(data, 'socket订阅');
    const msg = data.body;
    const path = window.location.href;
    switch (data.type) {
    case 'Order_Pay_Result': // 订单支付结果消息
        state.payOrder = msg;
        break;
    case 'JointTraining_Room': // 综合演练室-房间消息
        if (!path.includes('/plan') || !path.includes('/dp/')) {
            state.jointRoomInfo = msg; // 房间信息
        }
        break;
    case 'JointTraining_User': // 综合演练室-用户消息
        handleUserinfo(state, msg); // 分配角色权限消息
        break;
    case 'JointTraining_Chat': //  综合演练室-群聊消息
        handleRecordList(state, msg);
        break;
    case 'Simulation_DeviceStatus': // 仿真-设备状态消息
        state.equipmentStatus = msg;
        break;
    case 'Simulation_User': // 仿真-进出仿真消息
        handleSimulationUserinfo(state, msg); // 用户进出仿真消息
        break;
    case 'Simulation_Script_Action_Tip': // 剧本提示消息
        handleSimulationScriptTipInfo(state, msg); // 剧本提示消息
        break;
    case 'Simulation_Script_Action_Finish':
        state.simulationScriptTipFinish++; // 剧本某一部操作完成提示
        break;
    case 'Simulation_Script_Action_Error':
        state.simulationScriptTipError++; // 剧本某一部操作执行错误
        break;
    case 'Simulation_PlayBack_Finish': // 竞赛裁判系统裁判员回放结束推送
        state.playBackFinish++; // 竞赛裁判系统裁判员回放结束推送
        break;
    case 'Simulation_Over': // 用户退出仿真推送消息
        state.simulationOver++; // 用户退出仿真推送消息
        break;
    case 'Simulation_Script_Finish': // 剧本执行完成推送消息
        state.scriptFinish++; // 剧本执行完成推送消息
        break;
    case 'Simulation_Script_Action':// 剧本编制添加指令的推送消息
        state.scriptAction = msg;
        break;
    case 'Simulation_AutoFault_Trigger': // 自动故障触发操作推送消息
        state.autoFaultTrigger++;
        break;
    case 'Simulation_RunFact': // 仿真-列车实际到发车站消息
        if (!Array.isArray(msg)) {
            state.trainStationList = [msg];
        } else {
            state.trainStationList = msg;
        }
        break;
    case 'Simulation_Error': // 仿真-异常消息
        state.simulationError += 1;
        break;
    case 'Simulation_RunAsPlan_Start': // 仿真-仿真开始按计划行车消息
        state.simulationStart = msg;
        break;
    case 'Simulation_Reset': // 仿真-仿真重置消息 退出计划行车
        state.simulationReset += 1;
        break;
    case 'Simulation_Conversation': // 仿真-用户交互消息（聊天/命令）
        handleSimulationInfo(state, msg);
        break;
    case 'Simulation_PlayBack_Conversation': // 回放-用户交互消息
        handleSimulationInfo(state, msg);
        break;

    case 'Simulation_ApplyHandle': 	// 请求处理消息（旧版可能在用，新版地图不用这个）
        handlePushMsgQueue(state, msg);
        break;

    case 'JointTraining_User_Permit': // 综合演练室-用户获取权限消息
        state.userPermit = msg;
        break;
    case 'Simulation_Invite': // 综合演练-仿真邀请消息
        state.simulationInvite = msg;
        break;
    case 'JointTraining_Room_Invite': // 综合演练室-房间邀请消息
        state.roomInvite = msg;
        break;
    case 'Big_Screen_Simulation_DeviceStatus': // 大屏仿真状态数据
        state.equipmentStatus = msg;
        break;
    case 'Big_Screen_Simulation_RunFact': 	// 大屏仿真运行图状态
        state.trainStationList = msg;
        break;
    case 'Plan_Simulation_DeviceStatus': // 大屏仿真状态数据
        state.equipmentStatus = msg;
        break;
    case 'Plan_Simulation_RunFact': 	// 大屏仿真运行图状态
        state.trainStationList = msg;
        break;
    case 'Simulation_Permission_Over': // 权限结束
        state.permissionOver = msg;
        break;
    case 'Simulation_Quest_Finish': // 任务结束标志
        state.tipOperateCount++;
        break;
    case 'JointTraining_Device':
        state.realDeviceInfo++;
        break;
    case 'Be_Logged_Out': // 重复登录被登出
        state.beLogoutCount++;
        break;
    case 'Simulation_Run_Plan_Reload': // 运行图变更
        state.runPlanReloadCount++;
        break;
    case 'Simulation_Control_Pause': // 暂停中
        store.dispatch('scriptRecord/updateSimulationPause', msg);
        break;
    case 'BROADCAST': // 升级通知消息
        Notification.warning({
            title: msg.title,
            center: true,
            message: msg.message,
            position: 'bottom-right',
            showClose: msg.showClose,
            duration: 0
        });
        break;
    case 'Simulation_Member':
        state.memberChangeCount++;
        break;
    case 'Simulation_Time_Sync':
        state.simulationTimeSync = msg;
        break;
    case 'Simulation_IbpStatus':
        state.simulationIbpStatus = msg;
        break;
    case 'Simulation_Competition_Practice_Finish':
        state.competitionPracticeFinish++;
        break;
    case 'Simulation_Alarm':
        state.simulationAlarmInfo = msg;
        break;
    }

}

// 操作聊天信息
function handleRecordList(state, data) {
    const userId = store.state.user.id;
    let isSelf = false;
    if (data.member.id == userId) {
        isSelf = true;
    }
    const myDate = new Date();
    const myDate1 = myDate.toLocaleDateString().replace(/\//g, '-');
    const param = {
        join: false,
        value: data.message,
        self: isSelf,
        voice: data.isAudio,
        src: data.isAudio ? `/jlcloud/audio/${data.audioPath}` : '',
        other: !isSelf,
        userName: data.member.nickName,
        chatTime: data.chatTime,
        chatInfo: true,
        inSimulation: false,
        inRoom: true,
        date: +new Date(`${myDate1} ${data.chatTime}`)
    };
    state.chatContent = param;
}
// 仿真内部聊天
function handleSimulationInfo(state, data) {
    switch (data.messageType) {
    case 'INVITE':
        state.inviteSimulationConversition = data;
        break;
    case 'CONNECT':
        state.acceptConversionInvite = data;
        break;
    case 'OVER':
        state.overConversition = data;
        break;
    case 'MESSAGE':
        state.conversationInfo = data;
        break;
    case 'CREATE':
        state.createConversition = data;
        break;
    case 'EXIT':
        state.exitConversition = data;
        break;
    }
}

// 剧本提示
function handleSimulationScriptTipInfo(state, data) {
    state.simulationScriptTip = data;
}

function handleUserinfo(state, data) {
    state.roleList = (data instanceof Array) ? data : [data];
}

function handleSimulationUserinfo(state, data) {
    state.simulationRoleList = (data instanceof Array) ? data : [data];
}

// （旧版可能在用，新版地图不用这个）
function handlePushMsgQueue(state, msg) {
    if (msg instanceof Array) {
        state.msgQueue.concat(msg);
    } else {
        state.msgQueue.push(msg);
    }

    if (!state.msgHead) {
        state.msgHead = state.msgQueue[0];
    }
}

const socket = {
    namespaced: true,

    state: {
        payOrder: {}, // 支付消息
        jointRoomInfo: {}, // 受邀请房间信息
        chatContent: {}, // 聊天室聊天内容
        roleList: [], // 设置角色信息
        simulationRoleList:[], // 设置仿真的聊天角色信息
        simulationScriptTip:{}, // 剧本推送提示信息
        simulationScriptTipFinish:0, // 剧本某一步完成的消息
        simulationScriptTipError: 0, // 剧本某一步执行错误
        scriptFinish:0, // 剧本执行完成提示信息
        autoFaultTrigger:0, // 自动故障触发操作推送消息
        scriptAction:{}, // 剧本编制添加指令的推送消息
        playBackFinish:0, // 竞赛裁判系统裁判回放结束推送
        jointRoomPrepare: false, // 演练房间准备状态
        equipmentStatus: [], // 仿真-设备状态消息
        trainStationList: [], //  仿真-列车实际到发车站消息
        simulationError: 0, // 仿真-异常消息
        simulationStart: '',	// 仿真-开始消息
        simulationOver:0, // 退出仿真推送消息
        simulationReset: 0, // 仿真-异常消息
        inviteSimulationConversition: {}, // 仿真会话邀请消息
        acceptConversionInvite:{}, // 仿真会话成员接收邀请
        createConversition:{}, // 仿真创建会话
        overConversition: {}, // 仿真会话结束
        exitConversition: {}, // 仿真成员退出会话
        conversationInfo: {}, // 仿真会话消息

        message: {}, // 仿真聊天
        msgQueue: [],	// 命令请求列表（旧版控制权转移可能在用，新版不用这个）
        msgHead: null,	// 消息头（旧版控制权转移可能在用，新版不用这个）

        userPermit: {}, // 用户获取权限消息
        userRoomKickOut: {}, // 用户被踢出房间消息
        userInRoom: {}, // 用户从外部进入房间消息
        userOutRoom: {}, // 用户退出房间消息
        userInSimulation: {}, //  用户进入仿真消息
        userBackRoom: {}, // 用户从仿真返回房间消息
        simulationInvite: {}, // 用户扫码信息

        permissionOver: {}, // 权限结束

        roomIsSubscribe:false, // 房间是否订阅
        assistantIsSubscribe:false, // 综合演练仿真聊天是否订阅

        tipOperateCount: 0, // 任务结束提示消息
        realDeviceInfo: 0, // 真实设备信息
        beLogoutCount: 0, // 被登出
        runPlanReloadCount: 0, // 仿真运行图变更
        memberChangeCount: 0, // 仿真成员变更
        roomInvite: {},
        simulationTimeSync: '', // 仿真时间
        simulationIbpStatus: null,
        competitionPracticeFinish:0, //  竞赛场景结束标识
        simulationAlarmInfo: {} // 仿真报警信息
    },
    getters: {
    },
    mutations: {
        setJointRoomInfo: (state, jointRoomInfo) => {
            state.jointRoomInfo = jointRoomInfo;
        },

        setChatContent: (state, chatContent) => {
            state.chatContent = chatContent;
        },

        setEquipmentStatus: (state, equipmentStatus) => {
            state.equipmentStatus = equipmentStatus;
        },

        setTrainStationList: (state, trainStationList) => {
            state.trainStationList = trainStationList;
        },

        setSimulationStart: (state, simulationStart) => {
            state.simulationStart = simulationStart;
        },

        setSimulationReset: (state, simulationReset) => {
            state.simulationReset = simulationReset;
        },

        setPayOrder: (state, payOrder) => {
            state.payOrder = payOrder;
        },

        // （旧版可能在用，新版地图不用这个）
        shiftMsgQueue: (state) => {
            state.msgHead = null;
            state.msgQueue.shift();
            state.msgHead = state.msgQueue[0];
        },

        // （旧版可能在用，新版地图不用这个）
        pushMsgQueue: (state, msg) => {
            handlePushMsgQueue(state, msg);
        },

        setSimulationInvite: (state, simulationInvite) => {
            state.simulationInvite = simulationInvite;
        },
        setRoomInvite: (state, roomInvite) => {
            state.roomInvite = roomInvite;
        },
        setRoomSubscribe:(state, roomIsSubscribe)=>{
            state.roomIsSubscribe = roomIsSubscribe;
        },
        setAssistantSubscribe:(state, assistantIsSubscribe)=>{
            state.assistantIsSubscribe = assistantIsSubscribe;
        }
    },

    actions: {
        setStomp: ({ state }, res) => {
            handle(state, res);
        },

        setChatContent: ({ commit }, chatContent) => {
            commit('setChatContent', chatContent);
        },

        setJointRoomInfo: ({ commit }) => {
            commit('setJointRoomInfo', {});
        },

        setEquipmentStatus: ({ commit }) => {
            commit('setEquipmentStatus', []);
        },

        setTrainStationList: ({ commit }) => {
            commit('setTrainStationList', []);
        },

        setSimulationStart: ({ commit }) => {
            commit('setSimulationStart', '');
        },

        setSimulationReset: ({ commit }) => {
            commit('setSimulationReset', 0);
        },

        setSimulationInvite: ({ commit }) => {
            commit('setSimulationInvite', {});
        },
        setRoomInvite: ({ commit }) => {
            commit('setRoomInvite', {});
        },
        setMessage: ({ state }, data) => {
            if (!state.message[data.key]) {
                state.message[data.key] = [];
            }
            state.message[data.key].push(data.value);
        },

        setPayOrder: ({ commit }) => {
            commit('setPayOrder', {});
        },

        shiftMsgQueue: ({ commit }) => {
            commit('shiftMsgQueue');
        },

        // pushMsgQueue: ({ commit }, msg) => {
        //     commit('pushMsgQueue', msg);
        // },
        setRoomSubscribe:({ commit }, msg) => {
            commit('setRoomSubscribe', msg);
        },
        setAssistantSubscribe:({ commit }, msg) => {
            commit('setAssistantSubscribe', msg);
        }
    }
};

export default socket;