4dkankan-take-look/src/main/java/com/fdkankan/tk/service/impl/RoomServiceImpl.java

package com.fdkankan.tk.service.impl;
import java.io.File;
import java.io.IOException;
import java.util.*;

import cn.hutool.core.date.DateUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.jwt.JWTUtil;
import com.auth0.jwt.JWT;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fdkankan.redis.constant.RedisKey;
import com.fdkankan.redis.util.RedisUtil;
import com.fdkankan.tk.common.FilePath;
import com.fdkankan.tk.common.PageInfo;
import com.fdkankan.tk.common.ResultCode;
import com.fdkankan.tk.common.WxSharCodePath;
import com.fdkankan.tk.common.util.JwtUtil;
import com.fdkankan.tk.common.util.RedisKeyUtil;
import com.fdkankan.tk.common.util.RoomUtil;
import com.fdkankan.tk.common.util.UploadToOssUtil;
import com.fdkankan.tk.entity.Room;
import com.fdkankan.tk.entity.RoomUser;
import com.fdkankan.tk.entity.WxUser;
import com.fdkankan.tk.exception.BusinessException;
import com.fdkankan.tk.httpClient.FdKKService;
import com.fdkankan.tk.httpClient.client.FdKKClient;
import com.fdkankan.tk.httpClient.request.FdkkLoginRequest;
import com.fdkankan.tk.httpClient.response.FdkkResponse;
import com.fdkankan.tk.mapper.IRoomMapper;
import com.fdkankan.tk.mapper.IRoomUserMapper;
import com.fdkankan.tk.request.RoomAddParam;
import com.fdkankan.tk.request.RoomListParam;
import com.fdkankan.tk.response.RoomAddUserParam;
import com.fdkankan.tk.response.RoomVo;
import com.fdkankan.tk.response.SceneVo;
import com.fdkankan.tk.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 
 * @since 2022-09-19
 */
@Service
@Slf4j
public class RoomServiceImpl extends ServiceImpl<IRoomMapper, Room> implements IRoomService {

    @Autowired
    IRoomNumService roomNumService;
    @Autowired
    ISceneService sceneService;
    @Autowired
    UploadToOssUtil uploadToOssUtil;
    @Autowired
    IWxService wxService;
    @Value("${upload.query-path}")
    private String queryPath;
    @Autowired
    RedisUtil redisUtil;
    @Autowired
    IWxUserService wxUserService;
    @Autowired
    RoomUtil roomUtil;
    @Autowired
    FdKKService fdKKService;
    @Autowired
    IRoomUserService roomUserService;
    @Autowired
    IRoomVisitLogService roomVisitLogService;
    @Autowired
    IRoomDanmakuService roomDanmakuService;

    @Override
    public PageInfo pageList(RoomListParam param, String token,String wxToken) {
        if(StringUtils.isBlank(token) && StringUtils.isBlank(wxToken) ){
            Page<Room> page = new Page<>(param.getPageNum(),param.getPageSize());
            return PageInfo.PageInfo(page);
        }

        if(StringUtils.isNotBlank(wxToken)  ){      //微信小程序调用，返回协作者房间
            String wxUserId = JwtUtil.getUserName(wxToken);
            WxUser wxUser = wxUserService.getById(wxUserId);
            if(wxUser != null){
                param.setUserName(wxUser.getPhoneNumber());
            }
            Page<Room> page = this.getBaseMapper().pageList(new Page<>(param.getPageNum(),param.getPageSize()),param);
            for (Room record : page.getRecords()) {
                if(record.getRoomUserId() != null){
                    record.setRoomId(record.getRoomId() + "_"+ record.getRoomUserId());
                }
                record.setVisitPassword(null);
            }
            return PageInfo.PageInfo(page);
        }

        LambdaQueryWrapper<Room> wrapper = new LambdaQueryWrapper<>();
        if(StringUtils.isNotBlank(token)){
            String fdToken = String.format(RedisKey.TOKEN_V3,token);
            if(! redisUtil.hasKey(fdToken)){
                throw new BusinessException(ResultCode.USER_NOT_LOGIN);
            }
            redisUtil.expire(fdToken,6 * 60 * 60);
            String userName = JwtUtil.getUserName(token);
            wrapper.eq(Room::getRoomUserName,userName);
        }

        if (StringUtils.isNotBlank(param.getRoomTitle()) ) {
            wrapper.like(Room::getRoomTitle,param.getRoomTitle());
        }
        if(param.getRoomStatus() != null){
            if( param.getRoomStatus() == 0){
                wrapper.in(Room::getRoomStatus,0,1,2);
                wrapper.orderByAsc(Room::getRoomStatus);
            }else {
                wrapper.eq(Room::getRoomStatus,param.getRoomStatus());
            }
        }
        wrapper.orderByDesc(Room::getUpdateTime);

        Page<Room> page = this.page(new Page<>(param.getPageNum(), param.getPageSize()), wrapper);
        for (Room record : page.getRecords()) {
            record.setVisitPassword(null);
        }
        return PageInfo.PageInfo(page);
    }

    @Override
    public Room addOrUpdate(RoomAddParam param, String token) {
        if(param.getNumList() == null || param.getNumList().size() <=0){
            throw new BusinessException(ResultCode.PARAM_MISS);
        }
        if(StringUtils.isEmpty(param.getRoomTitle()) ){
            throw new BusinessException(ResultCode.PARAM_MISS);
        }
        Room room = new Room();
        BeanUtils.copyProperties(param,room);
        room.setRoomUserName(JwtUtil.getUserName(token));
        if(StringUtils.isEmpty(room.getRoomHostName())){
            room.setRoomHostName(room.getRoomUserName());
        }
        if(StringUtils.isNotBlank(room.getRoomId())){
            room.setUpdateTime(null);
            Room byId = this.getById(room.getRoomId());
            if(byId.getRoomStatus() == 1){
                throw new BusinessException(ResultCode.ROOM_ING);
            }
        }else {
            room.setRoomId(roomUtil.genRoomId(1000));
        }

        if(param.getNumList().size() >0){
            List<SceneVo> list = sceneService.getListByNumList(param.getNumList());
            if(list.size() >0){
                room.setRoomCoverUrl(list.get(0).getThumb());
            }
        }

        roomUserService.updateByUserObjList(param.getUserObjList(),room);
        this.saveOrUpdate(room);
        roomNumService.addBatch(room.getRoomId(),param.getNumList());
        param.setRoomId(room.getRoomId());
        return param;
    }

    @Override
    public void deleteById(String roomId) {
        Room room = this.getById(roomId);
        if(room == null ){
            throw new BusinessException(ResultCode.ROOM_MISS);
        }
        if(room.getRoomStatus() == 1){
            throw new BusinessException(ResultCode.DEL_ROOM_ING);
        }
        roomNumService.deleteByRoomId(roomId);
        roomUserService.delByRoomId(roomId);
        if(StringUtils.isNotBlank(room.getRoomShareUrl())){
            uploadToOssUtil.delete(room.getRoomShareUrl());
        }
        this.removeById(roomId);
    }

    @Override
    public RoomVo getRoomInfo(String roomId,String token,String wxToken) {
        log.info("getRoomInfo-request-roomId:{},token:{},wxToken:{}",roomId,token,wxToken);
        String roomUserId = null;
        if(roomId.contains("_")){
            String[] split = roomId.split("_");
            roomId = split[0];
            roomUserId = split[1];
        }
        Room room = this.getById(roomId);
        if(room == null){
            throw new BusinessException(ResultCode.ROOM_MISS);
        }
        List<String> numList = roomNumService.getListByRoomId(roomId);
        List<SceneVo> list = new ArrayList<>();
        if(numList.size() >0){
            list = sceneService.getListByNumList(numList);
        }
        RoomVo roomVo = new RoomVo();
        BeanUtils.copyProperties(room,roomVo);
        if(StringUtils.isBlank(token)){
            roomVo.setVisitPassword(null);
        }
        try {
            if(StringUtils.isNotBlank(wxToken)){

                WxUser wxUser = wxUserService.getById(JwtUtil.getUserName(wxToken));
                if(roomUserId != null){
                    RoomUser roomUser = roomUserService.getById(roomUserId);
                    if(roomUser != null){
                        if(wxUser.getPhoneNumber().equals(roomUser.getUserName())){
                            roomVo.setIsHost(1);
                        }
                    }
                }
                if(wxUser.getPhoneNumber().equals(room.getRoomUserName())){
                    roomVo.setIsHost(1);
                }
            }
        }catch (Exception e){
            log.error("查询微信用户失败：{}",e);
        }

        roomVo.setSceneData(list);
        List<RoomUser> roomUserList = roomUserService.getByRoomId(roomId);
        roomVo.setUserObjList(roomUserList);
        log.info("getRoomInfo-response-roomId:{},token:{},wxToken:{},roomVo:{}",roomId,token,wxToken,roomVo);
        return roomVo;
    }

    @Override
    public void roomAddView(String roomId) {
        LambdaUpdateWrapper<Room> wrapper = new LambdaUpdateWrapper<>();
        wrapper.setSql("room_view_count = room_view_count +1");
        wrapper.eq(Room::getRoomId,roomId);
        this.update(wrapper);
    }


    @Override
    public String getWxQrCode(String roomId,String type) {
        Room room = this.getById(roomId);
        if(room == null){
            throw new BusinessException(ResultCode.ROOM_MISS);
        }
        if(type.equals("follower") && StringUtils.isNotBlank(room.getRoomShareCode())){     //普通用户二维码
            if(uploadToOssUtil.existKey(room.getRoomShareCode()) && uploadToOssUtil.getSize(room.getRoomShareCode()) >0){
                return  room.getRoomShareCode() +"?"+System.currentTimeMillis();
            }
        }

        if(type.equals("leader") && StringUtils.isNotBlank(room.getRoomHostCode())){      //主持人二维码
            if(uploadToOssUtil.existKey(room.getRoomHostCode()) && uploadToOssUtil.getSize(room.getRoomHostCode()) >0){
                return  room.getRoomHostCode() +"?"+System.currentTimeMillis();
            }
        }
        if(type.equals("leader")){                          //检查房间场景可用性
            RoomVo roomVo = this.getRoomInfo(roomId,null,null);
            List<SceneVo> sceneData = roomVo.getSceneData();
            for (SceneVo sceneDatum : sceneData) {
                if(sceneDatum.getStatus() != 2){
                    throw new BusinessException(ResultCode.SCENE_STATUS_ERROR);
                }
            }
        }
        String path = null;
        if(type.equals("leader")){
            path = String.format(WxSharCodePath.hostCodePath,roomId,type,room.getRoomUserName());
        }else {
            path = String.format(WxSharCodePath.shardCodePath,roomId,"customer");
        }
        String localPath = String.format(FilePath.LOCAL_QRCODE_PATH, type,roomId);
        String ossPath = String.format(FilePath.OSS_QRCODE_PATH,type, roomId);
        wxService.getWxQRCode(path,localPath,0);
        if(!new File(localPath).exists()){
            throw new BusinessException(ResultCode.QRCODE_MISS);
        }
        uploadToOssUtil.uploadOss(localPath,ossPath);
        if(!uploadToOssUtil.existKey(ossPath)){
            FileUtil.del(localPath);
            throw new BusinessException(ResultCode.QRCODE_MISS);
        }
        if(type.equals("leader")){
            room.setRoomHostCode(queryPath + ossPath);
        }else {
            room.setRoomShareCode(queryPath + ossPath);
        }
        this.updateById(room);
        FileUtil.del(localPath);
        return queryPath + ossPath +"?"+System.currentTimeMillis();
    }


    /**
     * 加入房间，开启带看,退出房间
     * type 0 加入房间，1退出房间
     * role  follower  leader
     */
    @Override
    public void inOrOutRoom(String roomId, String role, Integer type,String userId) {
        log.info("inOrOutRoom--roomId:{},role:{},type:{},userId:{}",roomId,role,type,userId);
        if(roomId == null || StringUtils.isBlank(role)
                || ( !role.equals("leader") && !role.equals("follower")) ){
            throw new BusinessException(ResultCode.PARAM_MISS);
        }
        String wxRoomId = roomId;
        Integer roomUserId = null;
        if(roomId.contains("_")){
            String[] split = roomId.split("_");
            roomId =split[0];
            roomUserId = Integer.parseInt(split[1]);
        }
        Room room = this.getById(roomId);
        if(room == null){
            throw new BusinessException(ResultCode.ROOM_MISS);
        }

        if(room.getUseStartTime() != null && room.getUseStartTime().getTime() > new Date().getTime()){
            throw new BusinessException(ResultCode.ROOM_TIME_ERROR);
        }

        if(room.getUseEndTime() != null && room.getUseEndTime().getTime() <= new Date().getTime()){
            throw new BusinessException(ResultCode.ROOM_END_EX);
        }

        if(role.equals("follower")){
            if(type == 0 ){
                room.setRoomViewCount(room.getRoomViewCount() + 1);
            }
            roomVisitLogService.addLog(roomId,roomUserId,userId,type);
            room.setUpdateTime(null);
            this.updateById(room);
            return;
        }

        if(roomUserId != null){             //协作带看
            RoomUser roomuser = roomUserService.getById(roomUserId);
            if(type == 0 ){     //加入房间,开启带看
                roomuser.setRoomStatus(1);
            }
            roomuser.setUpdateTime(null);
            roomUserService.updateById(roomuser);
        }

        if(type == 0 ){     //加入房间,开启带看
            room.setRoomViewCount(room.getRoomViewCount() + 1);
            room.setRoomStatus(1);
            roomVisitLogService.addLog(roomId,roomUserId,userId,type);
        }
        if(type == 1 ){   //离开房间
            //this.stopRoom(roomId,roomUserId);
            roomVisitLogService.addLog(roomId,roomUserId,userId,type);
        }
        room.setLastLookTime(DateUtil.formatDateTime(new Date()));
        room.setUpdateTime(null);
        this.updateById(room);
    }


    @Override
    public Long getCountAndTbStatus() {
        return this.getBaseMapper().getCountAndTbStatus();
    }

    @Override
    public List<Room> getRunningRoom() {
        LambdaQueryWrapper<Room> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(Room::getRoomStatus,0,1);
        return this.list(wrapper);
    }

    @Override
    public void stopRoom(String roomId,Integer roomUserId) {
        if(roomUserId == null){
            LambdaUpdateWrapper<Room> wrapper = new LambdaUpdateWrapper<>();
            wrapper.eq(Room::getRoomId,roomId);
            wrapper.set(Room::getRoomStatus,2);
            this.update(wrapper);
            roomVisitLogService.stopRoom(roomId,roomUserId);
            roomDanmakuService.saveDanMaku(roomId,roomUserId);

            List<RoomUser> byRoomId = roomUserService.getByRoomId(roomId);
            for (RoomUser roomUser : byRoomId) {
                roomUserService.stopRoom(roomUser);
            }
        }else {
            RoomUser roomUser = roomUserService.getById(roomUserId);
            if(roomUser != null){
                roomUserService.stopRoom(roomUser);
            }
        }


    }

    @Override
    public HashMap<String, Room> getByIds(Set<String> roomIds) {
        HashMap<String,Room> map = new HashMap<>();
        if(roomIds.size() >0){
            List<Room> rooms = this.listByIds(roomIds);
            rooms.forEach(entity -> map.put(entity.getRoomId(),entity));
        }
        return map;
    }

    @Override
    public List<Room> getLikeTitle(String roomTitle) {
        LambdaQueryWrapper<Room> wrapper = new LambdaQueryWrapper<>();
        wrapper.like(Room::getRoomTitle,roomTitle);
        return this.list(wrapper);
    }

    @Override
    public List<Room> getRoomByToken(String token) {
        String userName = null;
        if(StringUtils.isNotBlank(token)){
            userName = JwtUtil.getUserName(token);
        }
        LambdaQueryWrapper<Room> wrapper = new LambdaQueryWrapper<>();
        if(StringUtils.isNotBlank(userName)){
            wrapper.eq(Room::getRoomUserName,userName);
        }
        wrapper.orderByDesc(Room::getRoomViewCount);
       return this.list(wrapper);
    }

    @Override
    public void addShareCount(String roomId) {
        LambdaUpdateWrapper<Room> wrapper = new LambdaUpdateWrapper<>();
        wrapper.setSql("share_count = share_count +1");
        wrapper.eq(Room::getRoomId,roomId);
        this.update(wrapper);
    }
}