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

package com.fdkankan.manage.controller.inner;

import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.extra.servlet.ServletUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.auth0.jwt.JWT;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.interfaces.DecodedJWT;
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.dtflys.forest.annotation.Post;
import com.fdkankan.common.util.JwtUtil;
import com.fdkankan.fyun.face.FYunFileServiceInterface;
import com.fdkankan.manage.common.*;
import com.fdkankan.manage.config.ManageConfig;
import com.fdkankan.manage.constant.FileTypeEnum;
import com.fdkankan.manage.controller.BaseController;
import com.fdkankan.manage.entity.*;
import com.fdkankan.manage.entity.Dict;
import com.fdkankan.manage.exception.BusinessException;
import com.fdkankan.manage.httpClient.client.HaixinClient;
import com.fdkankan.manage.httpClient.param.HaixinParam;
import com.fdkankan.manage.service.*;
import com.fdkankan.manage.service.impl.ManageService;
import com.fdkankan.manage.util.RsaUtils;
import com.fdkankan.manage.util.ShellUtil;
import com.fdkankan.manage.vo.EvidenceVo;
import com.fdkankan.manage.vo.request.*;
import com.fdkankan.manage.vo.response.ManageLoginResponse;
import com.fdkankan.manage.vo.response.SceneAuthVo;
import com.fdkankan.manage.vo.response.UserAuthSceneVo;
import com.fdkankan.manage.vo.response.UserShareSceneVo;
import com.fdkankan.rabbitmq.util.RabbitMqProducer;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;

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

    @Autowired
    IJyUserService jyUserService;
    @Autowired
    IUserService userService;
    @Autowired
    IJySceneUserAuthService jySceneUserAuthService;
    @Autowired
    IScenePlusService scenePlusService;
    @Autowired
    IJyUserShareService jyUserShareService;
    @Autowired
    IJySceneAuthService jySceneAuthService;
    @Autowired
    ManageConfig manageConfig;
    @Autowired
    ISysUserService sysUserService;
    @Autowired
    IJyPlatformService jyPlatformService;
    @Autowired
    ICaseService caseService;
    @Autowired
    ManageService manageService;
    @Autowired
    ICaseNumService caseNumService;
    @Autowired
    ICaseFusionRelationService caseFusionRelationService;
    @Autowired
    RabbitMqProducer rabbitMqProducer;


    @PostMapping("/getByRyId")
    public ResultData getByRyId(@RequestBody UserParam param){
        return ResultData.ok(jyUserService.getEntityByParam(param.getRyId(),param.getRyNo()));
    }
    @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);
        if(StringUtils.isBlank(param.getSourceType())){
            param.setSourceType("scene");
        }
        jySceneUserAuthService.addAuth(param);
        return ResultData.ok();
    }

    @PostMapping("/setAuthType")
    public ResultData setAuthType(@RequestBody JySceneUserAuth param){
        if(StringUtils.isBlank(param.getSourceType())){
            param.setSourceType("scene");
        }
        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())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        if(StringUtils.isBlank(param.getSourceType())){
            param.setSourceType("scene");
        }
        JyUser jyUser = jyUserService.getEntityByParam(param.getRyId(), param.getRyNo());
        JySceneUserAuth db = jySceneUserAuthService.getByNumAndJyUserId(jyUser.getId(),param.getNum(),param.getSourceType(),null);
        jySceneUserAuthService.delAuth(db);
        return ResultData.ok();
    }

    @PostMapping("/checkAuthOther")
    public ResultData checkAuthOther(@RequestBody JySceneUserAuth param){
        if(StringUtils.isBlank(param.getSourceType())){
            param.setSourceType("scene");
        }
        return ResultData.ok(jySceneUserAuthService.checkAuthOther(param));
    }


    @GetMapping("/checkNumAuth/{num}")
    public ResultData checkNumAuth(@PathVariable String num){
        String clientIP = ServletUtil.getClientIP(request);
        SceneAuthVo sceneAuthVo = jySceneUserAuthService.checkNumAuth(num, "scene", getToken(), clientIP, getUserName(), getPassword(),null);

        return ResultData.ok(updateByVisitType(sceneAuthVo,getToken()) );
    }

    @GetMapping("/checkCaseAuth/{num}/{sourceType}")
    public ResultData checkCaseAuth(@PathVariable String num,@PathVariable String sourceType){
        SceneAuthVo sceneAuthVo = new SceneAuthVo();
        String clientIP = ServletUtil.getClientIP(request);
        if("case".equals(sourceType)){
            List<CaseNum> caseNums = caseNumService.getByCaseId(Integer.valueOf(num));
            for (CaseNum caseNum : caseNums) {
                SceneAuthVo sceneAuthVoNum = jySceneUserAuthService.checkNumAuth(caseNum.getNum(), "scene", getToken(), clientIP, getUserName(), getPassword(),null);
                if(sceneAuthVoNum.getViewAuth()){
                    sceneAuthVo.setViewAuth(true);
                }
                if(sceneAuthVoNum.getEditAuth()){
                    sceneAuthVo.setEditAuth(true);
                    break;
                }
            }
            List<CaseFusionRelation> relationList = caseFusionRelationService.getByCaseId(Integer.valueOf(num));
            for (CaseFusionRelation caseFusionRelation : relationList) {
                SceneAuthVo sceneAuthVoNum = jySceneUserAuthService.checkNumAuth(caseFusionRelation.getFusionId().toString(), "fusion", getToken(), clientIP, getUserName(), getPassword(),null);
                if(sceneAuthVoNum.getViewAuth()){
                    sceneAuthVo.setViewAuth(true);
                }
                if(sceneAuthVoNum.getEditAuth()){
                    sceneAuthVo.setEditAuth(true);
                    break;
                }
            }
            return ResultData.ok(sceneAuthVo);
        }
        sceneAuthVo = jySceneUserAuthService.checkNumAuth(num, sourceType, getToken(), clientIP, getUserName(), getPassword(),null);
        return ResultData.ok(sceneAuthVo);
    }

    @PostMapping("/checkNumAuth")
    public ResultData checkNumAuth(@RequestBody JSONObject object){
        String clientIP = ServletUtil.getClientIP(request);
        SceneAuthVo sceneAuthVo = jySceneUserAuthService.checkNumAuth(object.getString("num"), "scene", getToken(), clientIP, object.getString("userName"), object.getString("password"),null);
        return ResultData.ok(updateByVisitType(sceneAuthVo,getToken()));
    }

    private SceneAuthVo updateByVisitType(SceneAuthVo sceneAuthVo,String token){
        if(!sceneAuthVo.getEditAuth()){
            return sceneAuthVo;
        }
        if(StringUtils.isNotBlank(token)){
            String visitType = getVisitType(token);
            if(StringUtils.isNotBlank(visitType) && "view".equals(visitType)){
                sceneAuthVo.setEditAuth(false);
            }
        }
        return sceneAuthVo;
    }

    public static String getVisitType(String token) {
        try {
            DecodedJWT jwt = JWT.decode(token);
            return jwt.getClaim("visitType").asString();
        } catch (JWTDecodeException var2) {
            return null;
        }
    }

    @PostMapping("/getAuthType")
    public ResultData getAuthType(@RequestBody SceneParam param){
        if(StringUtils.isBlank(param.getSourceType())){
            param.setSourceType("scene");
        }
        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.isBlank(param.getSourceType())){
            param.setSourceType("scene");
        }
        JySceneAuth jySceneAuth  = jySceneAuthService.getByNum(param.getNum(),param.getSourceType());
        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);
        }
        SysUser sysUser = sysUserService.getById(jyUser.getSysUserId());
        if(sysUser == null){
            throw new BusinessException(ResultCode.JY_ID_NO_EXIST);
        }

        AllShareParam allShareParam = new AllShareParam();
        if(jyUser.getPlatformId() !=null   && (sysUser.getRoleId() == 45L || sysUser.getRoleId() == 48L)){
            allShareParam.setPlatformId(jyUser.getPlatformId());
        }else {
            allShareParam.setUserId(jyUser.getId());
        }

        //设置全局公开场景
        if(!manageConfig.getNumList().isEmpty()){
            allShareParam.getNumList().addAll(manageConfig.getNumList());
        }

        //获取分享主用户
        List<JyUserShare> jyUserShares = jyUserShareService.getByJyUserId(jyUser.getId(),"scene");
        List<Integer> mainUserIds = jyUserShares.stream().map(JyUserShare::getMainJyUserId).collect(Collectors.toList());
        HashMap<Integer,Long> roleMap = new HashMap<>();
        if(!mainUserIds.isEmpty()){
            List<JyUser> jyUsers = jyUserService.listByIds(mainUserIds);
            Set<Long> sysIds = jyUsers.stream().map(JyUser::getSysUserId).collect(Collectors.toSet());
            HashMap<Long, SysUser> byIds = sysUserService.getByIds(sysIds);
            jyUsers.forEach( e-> roleMap.put(e.getId(),byIds.get(e.getSysUserId()).getRoleId()));

            for (JyUser user : jyUsers) {
                Long roleId = roleMap.get(user.getId());
                if(user.getPlatformId() != null && (roleId == 45L || roleId == 48L)){
                    allShareParam.getOtherPlatformIds().add(user.getPlatformId());
                }else {
                    allShareParam.getOtherUserIds().add(user.getId());
                }
            }
        }
        //获取本平台公开场景
        List<String> openNums = jySceneAuthService.getNumListByPlatform(jyUser.getPlatformId(),1,"scene");
        if(!openNums.isEmpty()){
            allShareParam.getNumList().addAll(openNums);
        }
        //获取授权场景
        HashMap<String,JySceneUserAuth> authHashMap = new HashMap<>();
        HashMap<String,JySceneUserAuth> openHashMap = new HashMap<>();
        List<JySceneUserAuth> jySceneUserAuths = jySceneUserAuthService.getByJyUserId(jyUser.getId());
        jySceneUserAuths.stream().filter(e ->e.getNum() != null && e.getAuthType() == 0).forEach( e-> authHashMap.put(e.getNum(),e));
        jySceneUserAuths.stream().filter(e ->e.getNum() != null && e.getAuthType() == 1).forEach( e-> openHashMap.put(e.getNum(),e));

        List<String> allAuthNum = new ArrayList<>();
        allAuthNum.addAll(authHashMap.keySet());
        allAuthNum.addAll(openHashMap.keySet());
        HashMap<String, JySceneAuth> authMap = jySceneAuthService.getByNumList(allAuthNum,"scene");

        if(!authHashMap.isEmpty()){
            List<String> authNumList = authHashMap.keySet().stream().filter(e -> authMap.get(e)!=null && authMap.get(e).getAuthType() == 0).collect(Collectors.toList());
            if(!authNumList.isEmpty()){
                allShareParam.getNumList().addAll(authNumList);
            }
        }
        if(!openHashMap.isEmpty()){
            List<String> openAuthNumList = openHashMap.keySet().stream().filter(e -> authMap.get(e)!=null && authMap.get(e).getAuthType() == 1).collect(Collectors.toList());
            if(!openAuthNumList.isEmpty()){
                allShareParam.getNumList().addAll(openAuthNumList);
            }
        }


        Page<UserShareSceneVo> page= scenePlusService.allScenePageList(new Page<>(param.getPageNum(), param.getPageSize()),allShareParam);

        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());
        HashMap<Integer,JyUser> userHashMap = new HashMap<>();

        for (UserAuthSceneVo record : page.getRecords()) {
            List<JySceneUserAuth> userAuths = map.get(record.getNum()+"_"+record.getAuthType());
            if(userAuths != null && !userAuths.isEmpty()){
                for (JySceneUserAuth userAuth : userAuths) {
                    JyUser jyUser2 = userHashMap.get(userAuth.getJyUserId());
                    if(jyUser2 == null){
                        JyUser jyUser1 = jyUserService.getById(userAuth.getJyUserId());
                        if(jyUser1 != null){
                            userHashMap.put(jyUser1.getId(),jyUser1);
                        }
                    }
                    jyUser2 = userHashMap.get(userAuth.getJyUserId());
                    if(jyUser2 != null){
                        userAuth.setRyId(jyUser2.getRyId());
                        userAuth.setRyNo(jyUser2.getRyNo());
                        userAuth.setRyNickName(jyUser2.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);
    }



    @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("/platformList")
    public ResultData list(@RequestBody JyPlatformParam param){
        return ResultData.ok(jyPlatformService.pageList(param));
    }


    @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);
    }


    @PostMapping("/getTokenByKno")
    public ResultData getTokenByKno(@RequestBody ManageLoginRequest param){
        if(StringUtils.isBlank(param.getKno()) &&  StringUtils.isBlank(param.getCaseId())){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        Case caseEntity ;
        if(StringUtils.isNotBlank(param.getCaseId())){
             caseEntity = caseService.getById(param.getCaseId());
        }else {
            caseEntity = caseService.getByKno(param.getKno());
        }
        if(caseEntity == null){
            throw new BusinessException(ResultCode.CASE_NOT_EXIST2);
        }
        Long sysUserId = caseEntity.getSysUserId();
        JyUser jyUser = jyUserService.getBySysId(sysUserId);

        param.setUserName(jyUser.getRyNo());
        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("caseId", caseEntity.getCaseId());
        return ResultData.ok(map);
    }


    @PostMapping("/updateKno")
    public ResultData updateKno(@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);
        }
        LambdaUpdateWrapper<ScenePlus> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(ScenePlus::getTaskId,param.getProjectId());
        wrapper.set(ScenePlus::getKNo,param.getKno());
        scenePlusService.update(wrapper);


        for (ScenePlus scenePlus : list) {
            List<CaseNum> caseNumList = caseNumService.getByNum(scenePlus.getNum());
            for (CaseNum caseNum : caseNumList) {
                caseNumService.removeById(caseNum.getId());
            }
            if(StringUtils.isNotBlank(param.getKno())){
                HashMap<String,Object> map = new HashMap<>();
                map.put("num",scenePlus.getNum());
                map.put("kNo",param.getKno());
                rabbitMqProducer.sendByWorkQueue("queue-aj-add-scene",map);
            }
        }

        return ResultData.ok();
    }

    @Autowired
    IDictService dictService;
    @Autowired
    IDictFileService dictFileService;
    @Autowired
    HaixinClient haixinClient;
    @Autowired
    ICommonUploadService commonUploadService;
    @Autowired
    IDictIconService dictIconService;

    @PostMapping("/traceEvidenceList")
    public ResultData traceEvidenceList(@RequestBody DictFileParam dictParam){
        List<Dict> dictList = dictService.getByUseType("trace_evidence",dictParam.getName());
        List<Integer> dictIds = dictList.stream().map(Dict::getId).collect(Collectors.toList());
        HashMap<Integer,List<DictIcon>> map = dictIconService.getMapGroupDict(dictIds);
        for (Dict dict : dictList) {
            dict.setDictIconList(map.get(dict.getId()));
        }
        return ResultData.ok(dictList);
    }

    @PostMapping("/traceEvidenceInfoList")
    public ResultData traceEvidenceInfoList(@RequestBody DictFileParam dictParam){
        dictParam.setTypeKey("media-library");
        return ResultData.ok(dictFileService.traceEvidenceInfoList(dictParam));
    }

    @GetMapping("/refreshTraceEvidenceInfoList/{kno}")
    public ResultData refreshTraceEvidenceInfoList(@PathVariable String kno){
        dictFileService.updateByKno(kno);
        return ResultData.ok();
    }

    @PostMapping("/addMediaLibrary")
    public ResultData addMediaLibrary(@RequestBody addMediaLibraryParam param){

        return ResultData.ok(dictFileService.addMediaLibrary(param));
    }

    @PostMapping("/addMediaLibrarys")
    public ResultData addMediaLibrarys(@RequestBody addMediaLibraryParams param){
        for (addMediaLibraryParam paramParam : param.getParams()) {
            dictFileService.checkMediaLibrary(paramParam);
        }
        List<DictFile> dictFiles = new ArrayList<>();
        for (addMediaLibraryParam paramParam : param.getParams()) {
            dictFiles.add(dictFileService.addMediaLibrary(paramParam));
        }
        return ResultData.ok(dictFiles);
    }

    @GetMapping("/getCaseByNum")
    public ResultData getCaseByNum(@RequestParam(required = false) String num){
        List<Case> caseByNum = caseService.getCaseByNum(num);
        for (Case aCase : caseByNum) {
            aCase.setKNumber(aCase.getCaseId().toString());
        }
        return ResultData.ok(caseByNum);
    }
}