mec/mec-im/src/main/java/com/ym/controller/RoomController.java

package com.ym.controller;

import com.alibaba.fastjson.JSONObject;
import com.ym.common.BaseResponse;
import com.ym.mec.biz.dal.dto.TencentData;
import com.ym.mec.biz.dal.enums.ETencentTRTCCallbackCommand;
import com.ym.pojo.*;
import com.ym.service.MessageService;
import com.ym.service.RoomService;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiImplicitParams;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.joda.time.DateTime;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Objects;

@RestController
@RequestMapping("/room")
@Slf4j
public class RoomController{
    @Autowired
    RoomService roomService;
    @Autowired
    MessageService messageService;

    @RequestMapping(value = "/join", method = RequestMethod.POST)
    public BaseResponse joinRoom(@RequestBody ReqUserData data) throws Exception {
        return roomService.joinRoom(data.getRoomId(), true);
    }

    @RequestMapping(value = "/joinLive", method = RequestMethod.POST)
    public BaseResponse joinLiveRoom(@RequestBody ReqUserData data) throws Exception {
        return new BaseResponse(roomService.joinRoom(data.getRoomId(), false));
    }

    @ApiOperation("查询网络教室信息")
    @ApiImplicitParams({
            @ApiImplicitParam(name = "roomId", value = "房间id", required = true, dataType = "String", paramType = "query")
    })
    @GetMapping(value = "/info")
    public BaseResponse getRoomInfo(@RequestParam String roomId) throws Exception {
        return roomService.joinRoom(roomId.substring(1), false);
    }

    @RequestMapping(value = "/signIn", method = RequestMethod.POST)
    public Object signIn(Long roomId){
        return new BaseResponse<>();
    }

    @RequestMapping(value = "/statusImMsg", method = RequestMethod.POST)
    public Object statusImMsg(ImMsg imMsg){
        return new BaseResponse<>();
    }

    @RequestMapping(value = "/leave", method = RequestMethod.POST)
    public Object leaveRoom(@RequestBody RoomStatusNotify roomStatusNotify) throws Exception {
        //成员退出
        roomService.leaveRoomSuccess(roomStatusNotify.getRoomId(), roomStatusNotify.getUserId(), roomStatusNotify.getDeviceNum());
        return new BaseResponse<>();
    }

    @RequestMapping(value = "/queryNoJoinStu", method = RequestMethod.GET)
    public Object queryNoJoinStu(String roomId){
        return new BaseResponse<>(roomService.queryNoJoinStu(roomId));
    }

    @RequestMapping(value = "/sendImPlayMidiMessage", method = RequestMethod.POST)
    public Object sendImPlayMidiMessage(@RequestBody PlayMidiMessageData playMidiMessageData) throws Exception {
        log.info("sendImPlayMidiMessage: {}",JSONObject.toJSON(playMidiMessageData));
        roomService.sendImPlayMidiMessage(playMidiMessageData);
        return new BaseResponse<>();
    }

    @RequestMapping(value = "pushDownloadExamSongMsg", method = RequestMethod.POST)
    public Object pushDownloadExamSongMsg(@RequestBody ExamSongData examSongData) throws Exception {
        roomService.pushDownloadExamSongMsg(examSongData.getRoomId(),examSongData.getExamSongId());
        return new BaseResponse<>();
    }

    @ApiOperation(value = "老师通知学员下载伴奏")
    @RequestMapping(value = "pushDownloadMusicScoreMsg", method = RequestMethod.POST)
    public Object pushDownloadMusicScoreMsg(@RequestBody MusicScoreData musicScoreData) throws Exception {
        roomService.pushDownloadMusicScoreMsg(musicScoreData);
        return new BaseResponse<>();
    }

    @RequestMapping(value = "joinRoomStatusNotify", method = RequestMethod.POST)
    public Object joinRoomStatusNotify(@RequestBody RoomStatusNotify roomStatusNotify) throws Exception {
        log.info("joinRoomStatusNotify: {}",JSONObject.toJSON(roomStatusNotify));
        String roomId = roomStatusNotify.getRoomId();
        String userId = roomStatusNotify.getUserId();
        String deviceNum = roomStatusNotify.getDeviceNum();
        if(roomStatusNotify.isRequestStatus()){
            roomService.joinRoomSuccess(roomId, userId,deviceNum);
        }else {
            roomService.joinRoomFailure(roomId, userId);
        }
        return new BaseResponse<>();
    }

    @RequestMapping(value = "/statusSync")
    public void statusSync(@RequestBody String body) throws Exception {
        try {
            ChannelStateNotify notify = JSONObject.parseObject(body, ChannelStateNotify.class);
            log.info("statusSyncParam: {}",JSONObject.toJSON(notify));
            String roomId = notify.getChannelId();
            String userId = notify.getUserId();
            switch (notify.getEvent()){
                case 11:
                    //成员加入
                    roomService.joinRoomSuccess(roomId, userId,null);
                    break;
                case 12:
                    //成员退出
                    roomService.leaveRoomSuccess(roomId, userId,null, notify.getTimestamp());
                    break;
            }
        }catch (Exception e){
            log.error(e.getLocalizedMessage());
        }
    }


    @PostMapping(value = "/statusSyncTencent")
    public void statusSyncTencent(@RequestBody TencentData.TRTCEventInfo eventInfo) {
        try {
            if (Objects.isNull(eventInfo.getEventInfo())) {
                log.warn("statusSyncTencent eventInfo is null, time={}", DateTime.now().toString("yyy-MM-dd HH:mm:ss"));
                return;
            }
            log.info("statusSyncTencent: {}", eventInfo.jsonString());
            String roomId = eventInfo.getEventInfo().getRoomId();

            // 网络教室回调整消息
            if (roomId.startsWith("S") || roomId.startsWith("I")) {
                // 进出用户信息
                String userId = eventInfo.getEventInfo().getUserId();
                switch (ETencentTRTCCallbackCommand.get(eventInfo.getEventType())){
                    case EVENT_TYPE_ENTER_ROOM:
                        //成员加入
                        roomService.joinRoomSuccess(roomId, userId,null);
                        break;
                    case EVENT_TYPE_EXIT_ROOM:
                        //成员退出
                        roomService.leaveRoomSuccess(roomId, userId,null, eventInfo.getCallbackTs());
                        break;
                    default:
                        // 默认事件，直接忽略
                        break;
                }
            }

            // 直播回调整消息, roomId.startsWith("LIVE")

        }catch (Exception e){
            log.error("statusSyncTencent event={}", eventInfo.jsonString(), e);
        }
    }

    @RequestMapping(value = "/downgrade", method = RequestMethod.POST)
    public Object downRole(@RequestBody ReqChangeUserRoleData data)
            throws Exception {
        boolean result = roomService.downgrade(data.getRoomId(), data.getUsers());
        return new BaseResponse<>(result);
    }

    @RequestMapping(value = "/kick", method = RequestMethod.POST)
    public Object kickMember(@RequestBody ReqUserData data)
            throws Exception {
        boolean result = roomService.kickMember(data.getRoomId());
        return new BaseResponse<>(result);
    }

    //only teacher
    @RequestMapping(value = "/display", method = RequestMethod.POST)
    public Object display(@RequestBody ReqDisplayData data)
            throws Exception {
        boolean result = roomService.display(data.getRoomId(), data.getType(), data.getUri(),data.getUserId());
        return new BaseResponse<>(result);
    }

    @RequestMapping(value = "/whiteboard/create", method = RequestMethod.POST)
    public Object createWhiteBoard(@RequestBody ReqWhiteboardData data)
            throws Exception {
        String result = roomService.createWhiteBoard(data.getRoomId());
        return new BaseResponse<>(result);
    }


    @RequestMapping(value = "/whiteboard/delete", method = RequestMethod.POST)
    public Object destroyWhiteBoard(@RequestBody ReqWhiteboardData data)
            throws Exception {
        boolean result = roomService.deleteWhiteboard(data.getRoomId(), data.getWhiteboardId());
        return new BaseResponse<>(result);
    }

    @RequestMapping(value = "/whiteboard/list", method = RequestMethod.GET)
    public Object getWhiteBoard(@RequestParam String roomId)
            throws Exception {
        List<RoomResult.WhiteboardResult> whiteboards = roomService.getWhiteboard(roomId);
        return new BaseResponse<>(whiteboards);
    }

    @ApiOperation(value = "通知学员打开，麦克风、摄像头等权限请求")
    @RequestMapping(value = "/device/approve", method = RequestMethod.POST)
    public Object approveControlDevice(@RequestBody ReqDeviceControlData data)
            throws Exception {
        boolean result;
        result = roomService.approveControlDevice(data);
        return new BaseResponse<>(result);
    }

    @RequestMapping(value = "/device/reject", method = RequestMethod.POST)
    public Object rejectControlDevice(@RequestBody ReqDeviceControlData data)
            throws Exception {
        boolean result;
        result = roomService.rejectControlDevice(data.getRoomId(), data.getTicket());
        return new BaseResponse<>(result);
    }

    @ApiOperation(value = "学员麦克风、摄像头等开关控制")
    @RequestMapping(value = "/device/control", method = RequestMethod.POST)
    public Object controlDevice(@RequestBody ReqDeviceControlData data)
            throws Exception {
        log.info("device_control: {}",JSONObject.toJSON(data));
        return new BaseResponse<>(roomService.controlDevice(data));
    }

    @ApiOperation(value = "学员伴奏下载状态回调")
    @RequestMapping(value = "adjustExamSong", method = RequestMethod.POST)
    public Object adjustExamSong(@RequestBody ExamSongData examSongData) throws Exception {
        log.info("adjustExamSong: {}",JSONObject.toJSON(examSongData));
        roomService.adjustExamSong(examSongData.getRoomId(),examSongData.getStatus(),examSongData.getExamSongId());
        return new BaseResponse<>();
    }

    @ApiOperation(value = "学员伴奏下载状态回调")
    @RequestMapping(value = "adjustMusicScore", method = RequestMethod.POST)
    public Object adjustMusicScore(@RequestBody MusicScoreData musicScoreData) throws Exception {
        roomService.adjustMusicScore(musicScoreData);
        return new BaseResponse<>();
    }

    @ApiOperation(value = "学员麦克风、摄像头等开关批量控制")
    @RequestMapping(value = "/device/batchControl", method = RequestMethod.POST)
    public Object batchControlDevice(@RequestBody ReqDeviceControlData data)throws Exception {
        log.info("batchControl: {}",JSONObject.toJSON(data));
        return new BaseResponse<>(roomService.batchControlDevice(data));
    }

    @RequestMapping(value = "/device/sync", method = RequestMethod.POST)
    public Object syncDeviceState(@RequestBody ReqDeviceControlData data)
            throws Exception {
        log.info("syncDeviceState: {}",JSONObject.toJSON(data));
        return new BaseResponse<>(roomService.syncDeviceState(data));
    }

    @RequestMapping(value = "/whiteboard/turn-page", method = RequestMethod.POST)
    public Object turnPage(@RequestBody ReqWhiteboardData data)
            throws Exception {
        boolean result = roomService.turnWhiteBoardPage(data.getRoomId(), data.getWhiteboardId(), data.getPage());
        return new BaseResponse<>(result);
    }

    @ApiImplicitParams({
            @ApiImplicitParam(name = "roomId", value = "房间id", required = true, dataType = "String"),
            @ApiImplicitParam(name = "userId", value = "用户Id", dataType = "String"),
    })
    @RequestMapping(value = "/members", method = RequestMethod.GET)
    public Object getMembers(@RequestParam String roomId, @RequestParam String userId)
            throws Exception {
        List<RoomResult.MemberResult> whiteboards = roomService.getMembers(roomId, userId);
        return new BaseResponse<>(whiteboards);
    }

    @RequestMapping(value = "/speech/apply", method = RequestMethod.POST)
    public Object apply(@RequestBody ReqSpeechData data)
            throws Exception {
        Boolean result = roomService.applySpeech(data.getRoomId());
        return new BaseResponse<>(result);
    }

    @RequestMapping(value = "/speech/approve", method = RequestMethod.POST)
    public Object approval(@RequestBody ReqSpeechData data)
            throws Exception {
        Boolean result = roomService.approveSpeech(data.getRoomId(), data.getTicket());
        return new BaseResponse<>(result);
    }

    @RequestMapping(value = "/speech/reject", method = RequestMethod.POST)
    public Object reject(@RequestBody ReqSpeechData data)
            throws Exception {
        Boolean result = roomService.rejectSpeech(data.getRoomId(), data.getTicket());
        return new BaseResponse<>(result);
    }

    @RequestMapping(value = "/transfer", method = RequestMethod.POST)
    public Object transfer(@RequestBody ReqUpgradeRoleData data)
            throws Exception {
        Boolean result = roomService.transfer(data.getRoomId(), data.getUserId());
        return new BaseResponse<>(result);
    }

    @RequestMapping(value = "/upgrade/invite", method = RequestMethod.POST)
    public Object inviteUpgradeRole(@RequestBody ReqUpgradeRoleData data)
            throws Exception {
        Boolean result = roomService.inviteUpgradeRole(data.getRoomId(), data.getUserId(), data.getRole());
        return new BaseResponse<>(result);
    }

    @RequestMapping(value = "/upgrade/approve", method = RequestMethod.POST)
    public Object approveUpgradeRole(@RequestBody ReqUpgradeRoleData data)
            throws Exception {
        Boolean result = roomService.approveUpgradeRole(data.getRoomId(), data.getTicket());
        return new BaseResponse<>(result);
    }

    @RequestMapping(value = "/upgrade/reject", method = RequestMethod.POST)
    public Object rejectUpgradeRole(@RequestBody ReqUpgradeRoleData data)
            throws Exception {
        Boolean result = roomService.rejectUpgradeRole(data.getRoomId(), data.getTicket());
        return new BaseResponse<>(result);
    }

    @RequestMapping(value = "/change-role", method = RequestMethod.POST)
    public Object changeRole(@RequestBody ReqChangeRole data)
            throws Exception {
        Boolean result = roomService.changeRole(data.getRoomId(), data.getUserId(), data.getRole());
        return new BaseResponse<>(result);
    }

    @RequestMapping(value = "/members/online-status", method = RequestMethod.POST)
    public Object memberOnlineStatus(@RequestBody List<ReqMemberOnlineStatus> statusList,
                                     @RequestParam(value = "timestamp", required = false) String timestamp,
                                     @RequestParam(value = "nonce", required = false) String nonce,
                                     @RequestParam(value = "signature", required = false) String signature)
            throws Exception {
        Boolean result = roomService.memberOnlineStatus(statusList, nonce, timestamp, signature);
        return new BaseResponse<>(result);
    }
}