4dkankan-center-manage/src/main/java/com/fdkankan/manage/controller/inner/InnerAPIController.java

package com.fdkankan.manage.controller.inner;

import cn.hutool.extra.servlet.ServletUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.dtflys.forest.annotation.Post;
import com.fdkankan.manage.common.CameraTypeEnum;
import com.fdkankan.manage.common.PageInfo;
import com.fdkankan.manage.common.ResultCode;
import com.fdkankan.manage.common.ResultData;
import com.fdkankan.manage.controller.BaseController;
import com.fdkankan.manage.entity.*;
import com.fdkankan.manage.exception.BusinessException;
import com.fdkankan.manage.service.*;
import com.fdkankan.manage.service.impl.ManageService;
import com.fdkankan.manage.util.RsaUtils;
import com.fdkankan.manage.vo.request.*;
import com.fdkankan.manage.vo.response.ManageLoginResponse;
import com.fdkankan.manage.vo.response.UserAuthSceneVo;
import com.fdkankan.manage.vo.response.UserShareSceneVo;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.*;
import java.util.stream.Collectors;

@RestController
@RequestMapping("/service/manage/inner")
public class InnerAPIController extends BaseController {

    @Autowired
    IJyUserService jyUserService;
    @Autowired
    IUserService userService;
    @Autowired
    IJySceneUserAuthService jySceneUserAuthService;
    @Autowired
    IScenePlusService scenePlusService;
    @Autowired
    IJyUserShareService jyUserShareService;
    @Autowired
    IJySceneAuthService jySceneAuthService;

    @PostMapping("/getByRyId")
    public ResultData getByRyId(@RequestBody UserParam param){
        if(StringUtils.isBlank(param.getRyNo()) && StringUtils.isBlank(param.getRyId())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        JyUser jyuser = null;
        if(StringUtils.isNotBlank(param.getRyId())){
            jyuser = jyUserService.getByRyId(param.getRyId());
            if(jyuser == null){
                throw new BusinessException(ResultCode.JY_ID_NO_EXIST);
            }
        }
        if(StringUtils.isNotBlank(param.getRyNo())){
            jyuser = jyUserService.getByRyNo(param.getRyNo());
            if(jyuser == null){
                throw new BusinessException(ResultCode.JY_ID_NO_EXIST);
            }
        }
        return ResultData.ok(jyuser);
    }
    @PostMapping("/getByRyNo")
    public ResultData getByRyNo(@RequestBody UserParam param){
        return ResultData.ok(jyUserService.getByRyNo(param.getRyNo()));
    }

    @PostMapping("/updateStatus")
    public ResultData updateStatus(@RequestBody UserParam userParam){
        userService.updateStatus(userParam);
        return ResultData.ok();
    }

    @PostMapping("/addUcenterUser")
    public ResultData addUcenterUser(@RequestBody UserParam param){
        userService.addUcenterUser(param);
        return ResultData.ok();
    }


    @PostMapping("/delUcenterUser")
    public ResultData delUcenterUser(@RequestBody UserParam param){
        userService.delUcenterUser(param);
        return ResultData.ok();
    }


    @PostMapping("/addAuth")
    public ResultData addAuth(@RequestBody JySceneUserAuth param){
        param.setCanDel(1);
        jySceneUserAuthService.addAuth(param);
        return ResultData.ok();
    }

    @PostMapping("/setAuthType")
    public ResultData setAuthType(@RequestBody JySceneUserAuth param){
        jySceneUserAuthService.setAuthType(param);
        return ResultData.ok();
    }

    @PostMapping("/delAuth")
    public ResultData delAuth(@RequestBody JySceneUserAuth param){
        if(StringUtils.isBlank(param.getRyId()) && StringUtils.isBlank(param.getRyNo())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        if(StringUtils.isBlank(param.getNum()) && param.getCaseId() == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        if(StringUtils.isNotBlank(param.getNum()) && param.getCaseId() != null){
            param.setCaseId(null);
        }
        JySceneUserAuth db = null;
        if(StringUtils.isNotBlank(param.getRyId()) && StringUtils.isNotBlank(param.getNum())){
            db = jySceneUserAuthService.getByNumAndRyId(param.getNum(),param.getRyId());
        }
        if(StringUtils.isNotBlank(param.getRyNo()) && StringUtils.isNotBlank(param.getNum())){
            db = jySceneUserAuthService.getByNumAndRyNo(param.getNum(),param.getRyNo());
        }
        if(StringUtils.isNotBlank(param.getRyId()) && param.getCaseId() != null){
            db = jySceneUserAuthService.getByCaseIdAndRyId(param.getCaseId(),param.getRyId());
        }
        if(StringUtils.isNotBlank(param.getRyNo()) && param.getCaseId() != null){
            db = jySceneUserAuthService.getByCaseIdAndRyNo(param.getCaseId(),param.getRyNo());
        }
        if(db == null){
            throw new BusinessException(ResultCode.DEL_AUTH_ERROR);
        }
        jySceneUserAuthService.delAuth(db);
        return ResultData.ok();
    }

    @PostMapping("/checkAuthOther")
    public ResultData checkAuthOther(@RequestBody JySceneUserAuth param){
        return ResultData.ok(jySceneUserAuthService.checkAuthOther(param));
    }


    @GetMapping("/checkNumAuth/{num}")
    public ResultData checkNumAuth(@PathVariable String num){
        String clientIP = ServletUtil.getClientIP(request);

        return ResultData.ok( jySceneUserAuthService.checkNumAuth(num,null,getToken(),clientIP,getUserName(),getPassword()));
    }
    @GetMapping("/checkCaseAuth/{caseId}")
    public ResultData checkCaseAuth(@PathVariable Integer caseId){
        String clientIP = ServletUtil.getClientIP(request);

        return ResultData.ok( jySceneUserAuthService.checkNumAuth(null,caseId,getToken(),clientIP,getUserName(),getPassword()));
    }

    @PostMapping("/checkNumAuth")
    public ResultData checkNumAuth(@RequestBody JSONObject object){
        String clientIP = ServletUtil.getClientIP(request);

        return ResultData.ok( jySceneUserAuthService.checkNumAuth(object.getString("num"),null,getToken(),clientIP,object.getString("userName"),object.getString("password")));
    }

    @PostMapping("/getAuthType")
    public ResultData getAuthType(@RequestBody SceneParam param){

        return ResultData.ok(jySceneUserAuthService.getAuthType(param));
    }

    @PostMapping("/getAuthList")
    public ResultData getAuthList(@RequestBody SceneParam param){
        if(StringUtils.isBlank(param.getRyId()) && StringUtils.isBlank(param.getRyNo())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        if(StringUtils.isBlank(param.getNum()) && param.getCaseId() == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        if(StringUtils.isNotBlank(param.getNum()) && param.getCaseId() != null){
            param.setCaseId(null);
        }
        JySceneAuth jySceneAuth = null;
        if(StringUtils.isNotBlank(param.getNum())){
            jySceneAuth = jySceneAuthService.getByNum(param.getNum());
        }
        if(param.getCaseId() != null){
            jySceneAuth = jySceneAuthService.getByCaseId(param.getCaseId());
        }
        if(jySceneAuth == null){
            return ResultData.ok(PageInfo.PageInfoEmpty(param.getPageNum(),param.getPageSize()));
        }
        param.setAuthType(jySceneAuth.getAuthType());
        return ResultData.ok(jySceneUserAuthService.getAuthList(param));
    }

    @PostMapping("/getSceneList")
    public ResultData getSceneList(@RequestBody SceneParam param){
        if(StringUtils.isBlank(param.getRyId()) && StringUtils.isBlank(param.getRyNo())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        JyUser jyUser = null;
        if(StringUtils.isNotBlank(param.getRyId()) ){
            jyUser = jyUserService.getByRyId(param.getRyId());
            if(jyUser == null){
                throw new BusinessException(ResultCode.JY_ID_NO_EXIST);
            }
        }
        if(StringUtils.isNotBlank(param.getRyNo()) ){
            jyUser = jyUserService.getByRyNo(param.getRyNo());
            if(jyUser == null){
                throw new BusinessException(ResultCode.JY_ID_NO_EXIST);
            }
        }
        if(jyUser == null){
            throw new BusinessException(ResultCode.JY_ID_NO_EXIST);
        }

        UserShareParam shareParam = new UserShareParam();
        shareParam.setJyUserId(Math.toIntExact(jyUser.getUserId()));
        shareParam.setPageNum(param.getPageNum());
        shareParam.setPageSize(param.getPageSize());
        Page<UserShareSceneVo> page= jyUserShareService.sceneList(shareParam);
        List<String> numList = page.getRecords().stream().map(UserShareSceneVo::getNum).collect(Collectors.toList());
        HashMap<String, JySceneAuth> authMap = jySceneAuthService.getByNumList(numList);
        HashMap<String, List<JySceneUserAuth>> userSceneAuthMap = jySceneUserAuthService.getByNumList(numList);
        HashSet<Integer> userIds = new HashSet<>();
        for (String key : userSceneAuthMap.keySet()) {
            List<JySceneUserAuth> userAuths = userSceneAuthMap.get(key);
            for (JySceneUserAuth userAuth : userAuths) {
                userIds.add(userAuth.getJyUserId());
            }
        }
        HashMap<Integer, JyUser> userHashMap = jyUserService.getByIds(new ArrayList<>(userIds));

        for (UserShareSceneVo record : page.getRecords()) {
            JySceneAuth jySceneAuth = authMap.get(record.getNum());
            if(jySceneAuth != null){
                record.setAuthType(jySceneAuth.getAuthType());
                List<JySceneUserAuth> userAuths = userSceneAuthMap.get(record.getNum()+"_"+jySceneAuth.getAuthType());
                if(userAuths != null && !userAuths.isEmpty()){
                    for (JySceneUserAuth userAuth : userAuths) {
                        JyUser jyUser1 = userHashMap.get(userAuth.getJyUserId());
                        if(jyUser1 != null){
                            userAuth.setRyId(jyUser1.getRyId());
                            userAuth.setRyNo(jyUser1.getRyNo());
                            userAuth.setRyNickName(jyUser1.getRyNickName());
                        }
                    }
                    record.setAuthList(userAuths);
                }
            }
        }

        return ResultData.ok(PageInfo.PageInfo(page));
    }

    @PostMapping("/getAuthSceneList")
    public ResultData getAuthSceneList(@RequestBody SceneParam param){
        if(StringUtils.isBlank(param.getRyId()) && StringUtils.isBlank(param.getRyNo())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        JyUser jyUser = null;
        if(StringUtils.isNotBlank(param.getRyId()) ){
            jyUser = jyUserService.getByRyId(param.getRyId());
            if(jyUser == null){
                throw new BusinessException(ResultCode.JY_ID_NO_EXIST);
            }
        }
        if(StringUtils.isNotBlank(param.getRyNo()) ){
            jyUser = jyUserService.getByRyNo(param.getRyNo());
            if(jyUser == null){
                throw new BusinessException(ResultCode.JY_ID_NO_EXIST);
            }
        }
        if(jyUser == null){
            throw new BusinessException(ResultCode.JY_ID_NO_EXIST);
        }

        UserShareParam shareParam = new UserShareParam();
        shareParam.setPageNum(param.getPageNum());
        shareParam.setPageSize(param.getPageSize());
        shareParam.setJyUserId(jyUser.getId());
        Page<UserAuthSceneVo> page= jyUserShareService.sceneAuthVoList(shareParam);
        List<String> numList = page.getRecords().stream().map(UserAuthSceneVo::getNum).collect(Collectors.toList());
        HashMap<String, List<JySceneUserAuth>> map  = jySceneUserAuthService.getByNumList(numList,jyUser.getId());
        for (UserAuthSceneVo record : page.getRecords()) {
            List<JySceneUserAuth> userAuths = map.get(record.getNum()+"_"+record.getAuthType());
            if(userAuths != null && !userAuths.isEmpty()){
                for (JySceneUserAuth userAuth : userAuths) {
                    JyUser jyUser1 = jyUserService.getById(userAuth.getJyUserId());
                    if(jyUser1 != null){
                        userAuth.setRyId(jyUser1.getRyId());
                        userAuth.setRyNo(jyUser1.getRyNo());
                        userAuth.setRyNickName(jyUser1.getRyNickName());
                    }
                }
                record.setAuthList(userAuths);
            }
        }

        return ResultData.ok(PageInfo.PageInfo(page));
    }

    @Autowired
    IDownService downService;

    /**
     * 检查下载
     * num      场景码
     */
    @GetMapping("/checkDownLoad")
    public ResultData checkDownLoad(@RequestParam(required = false) String num,
                                    @RequestParam(required = false,defaultValue = "0") Integer isObj){
        return ResultData.ok(downService.checkDownLoad(num,isObj));
    }

    /**
     * 下载场景
     * num      场景码
     */
    @GetMapping("/downScene")
    public ResultData downScene(@RequestParam(required = false) String num,
                                @RequestParam(required = false,defaultValue = "0") Integer isObj){
        return ResultData.ok(downService.down(num,isObj));
    }

    /**
     * 下载场景进度条
     * num      场景码
     */
    @GetMapping("/downloadProcess")
    public ResultData downloadProcess(@RequestParam(required = false) String num,
                                      @RequestParam(required = false,defaultValue = "0") Integer isObj){
        return ResultData.ok(downService.downloadProcess(num,isObj));
    }


    @Autowired
    ICameraService cameraService;
    @PostMapping(value = "/cameraInStore")
    public ResultData cameraInStore(@RequestBody CameraInStoreParam param){
        if(StringUtils.isBlank(param.getSnCode()) || param.getCameraType() == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        Camera camera = cameraService.getBySnCode(param.getSnCode());
        if(camera !=null){
            return ResultData.ok(camera);
        }
        String wifiPre = CameraTypeEnum.getCameraPrefixByType(param.getCameraType());
        cameraService.in(wifiPre + param.getSnCode().toUpperCase());
        camera = cameraService.getBySnCode(param.getSnCode());
        return ResultData.ok(camera);
    }

    @Autowired
    ManageService manageService;

    @PostMapping("/getTokenByRyNo")
    public ResultData getTokenByRyNo(@RequestBody ManageLoginRequest param){
        if(StringUtils.isBlank(param.getRyNo())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        param.setUserName(param.getRyNo());
        String clientIP = ServletUtil.getClientIP(request);
        param.setNeedPassword(false);
        param.setClientIp(clientIP);
        ManageLoginResponse login = manageService.login(param);
        return ResultData.ok(login.getToken());
    }

    @PostMapping("/getTokenByProjectId")
    public ResultData getTokenByProjectId(@RequestBody ManageLoginRequest param){
        if(StringUtils.isBlank(param.getProjectId())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        LambdaQueryWrapper<ScenePlus> sceneQw = new LambdaQueryWrapper<>();
        sceneQw.eq(ScenePlus::getTaskId,param.getProjectId());
        List<ScenePlus> list = scenePlusService.list(sceneQw);
        if(list == null || list.isEmpty()){
            throw new BusinessException(ResultCode.SCENE_NOT_EXIST);
        }
        ScenePlus scenePlus = list.get(0);
        User user = userService.getById(scenePlus.getUserId());
        if(user == null){
            throw new BusinessException(ResultCode.JY_ID_NO_EXIST);
        }

        param.setUserName(user.getUserName());
        String clientIP = ServletUtil.getClientIP(request);
        param.setNeedPassword(false);
        param.setClientIp(clientIP);
        ManageLoginResponse login = manageService.login(param);
        HashMap<String,Object> map = new HashMap<>();
        map.put("token",login.getToken());
        map.put("num",scenePlus.getNum());
        return ResultData.ok(map);
    }
}