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.extension.plugins.pagination.Page;
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.JySceneAuth;
import com.fdkankan.manage.entity.JySceneUserAuth;
import com.fdkankan.manage.entity.JyUser;
import com.fdkankan.manage.entity.UserShareParam;
import com.fdkankan.manage.exception.BusinessException;
import com.fdkankan.manage.service.*;
import com.fdkankan.manage.util.RsaUtils;
import com.fdkankan.manage.vo.request.SceneParam;
import com.fdkankan.manage.vo.request.UserParam;
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.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
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.getNum()) || (StringUtils.isBlank(param.getRyId()) && StringUtils.isBlank(param.getRyNo()))){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        JySceneUserAuth db = null;
        if(StringUtils.isNotBlank(param.getRyId())){
            db = jySceneUserAuthService.getByNumAndRyId(param.getNum(),param.getRyId());
        }
        if(StringUtils.isNotBlank(param.getRyNo())){
            db = jySceneUserAuthService.getByNumAndRyNo(param.getNum(),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,getToken(),clientIP,getUserName(),getPassword()));
    }

    @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())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        JySceneAuth jySceneAuth = jySceneAuthService.getByNum(param.getNum());
        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.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));
    }
}