4dkankan-fusion/src/main/java/com/fdkankan/fusion/service/impl/CaseServiceImpl.java

package com.fdkankan.fusion.service.impl;

import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.bean.BeanUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fdkankan.fusion.common.ResultCode;
import com.fdkankan.fusion.common.ResultData;
import com.fdkankan.fusion.common.util.NumTypeUtils;
import com.fdkankan.fusion.entity.*;
import com.fdkankan.fusion.exception.BusinessException;
import com.fdkankan.fusion.common.PageInfo;
import com.fdkankan.fusion.mapper.ICaseMapper;
import com.fdkankan.fusion.request.CaseParam;
import com.fdkankan.fusion.request.ScenePram;
import com.fdkankan.fusion.response.CaseVo;
import com.fdkankan.fusion.response.HotVo;
import com.fdkankan.fusion.response.SceneVo;
import com.fdkankan.fusion.service.*;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.lang.model.element.TypeElement;
import java.time.Period;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 
 * @since 2022-07-27
 */
@Service
public class CaseServiceImpl extends ServiceImpl<ICaseMapper, CaseEntity> implements ICaseService {

    @Autowired
    ISceneService sceneService;
    @Autowired
    ICaseNumService caseNumService;
    @Autowired
    ICaseFilesService caseFilesService;
    @Autowired
    IModelService modelService;
    @Autowired
    IFusionNumService fusionNumService;
    @Autowired
    ITmProjectService tmProjectService;
    @Autowired
    ITmDepartmentService tmDepartmentService;
    @Autowired
    ITmUserService tmUserService;
    @Autowired
    ITmCameraService tmCameraService;
    @Autowired
    IMapConfigService mapConfigService;

    @Override
    public PageInfo pageList(CaseParam param) {
        LambdaQueryWrapper<CaseEntity> wrapper = new LambdaQueryWrapper<>();
        if(StringUtils.isNotBlank(param.getCaseTitle())){
            wrapper.like(CaseEntity::getCaseTitle,param.getCaseTitle());
        }
        //wrapper.eq(CaseEntity::getUserName,userName);
        wrapper.eq(CaseEntity::getType,0);
        wrapper.orderByDesc(CaseEntity::getCreateTime);
        Page<CaseEntity> page = this.page( new Page<>(param.getPageNum(), param.getPageSize()), wrapper);

        List<Integer> mapIds = page.getRecords().stream().map(CaseEntity::getMapId).collect(Collectors.toList());
        if(!mapIds.isEmpty()){
            HashMap<Integer,MapConfig> map = mapConfigService.getMapByIds(mapIds);
            for (CaseEntity caseEntity : page.getRecords()) {
                if(caseEntity.getMapId() != null && map.get(caseEntity.getMapId()) != null){
                    MapConfig mapConfig = map.get(caseEntity.getMapId());
                    caseEntity.setMapConfig(mapConfig);
                }
            }
        }

        return PageInfo.PageInfo(page);
    }

    @Override
    public List<SceneVo> sceneList(CaseParam param) {
        if(param.getCaseId() == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        if(param.getTypeMap() == null){
            HashMap<Integer, List<String>> typeMap = caseNumService.getTypeMap(param.getCaseId());
            param.setTypeMap(typeMap);
        }
        List<SceneVo> listAll = new ArrayList<>();
        for (Integer type : param.getTypeMap().keySet()) {
            List<String> numList = param.getTypeMap().get(type);
            if(numList ==null || numList.size() <=0 || type ==3){
                continue;
            }
            if(param.getTypeList() != null && !param.getTypeList().contains(type)){
                continue;
            }
            ScenePram scenePram = new ScenePram();
            scenePram.setType(type);
            scenePram.setPageNum(1);
            scenePram.setPageSize(99999);
            scenePram.setNumList(param.getTypeMap().get(type));
            scenePram.setShare("1");
            if(param.getTypeList() != null){
                scenePram.setStatus(2);
            }
            scenePram.setSceneName(param.getSceneName());
            PageInfo pageInfo = sceneService.pageList(scenePram);
            List<SceneVo> list1 = (List<SceneVo>) pageInfo.getList();
            listAll.addAll(list1);

        }
        if(listAll.size() >0){
            List<String> numList = listAll.parallelStream().map(SceneVo::getNum).collect(Collectors.toList());
            //设置模型
            HashMap<String,Model> map = modelService.getMapByNum(numList);
            for (SceneVo sceneVo : listAll) {
                String createTime = sceneVo.getCreateTime();
                Model model = map.get(sceneVo.getNum() + sceneVo.getType());
                if(model == null){
                    continue;
                }
                BeanUtils.copyProperties(model,sceneVo);
                sceneVo.setCreateTime(createTime);
            }
        }
        //官网删除的场景，删除对应资源
        if(param.getTypeList() == null ){
            for (Integer type : param.getTypeMap().keySet()) {
                List<String> dbNumList = listAll.stream().filter(entity -> entity.getType().equals(type)).map(SceneVo::getNum).collect(Collectors.toList());
                this.deleteNotInScene(param.getTypeMap().get(type), dbNumList,type,param.getCaseId(),listAll);
            }
        }


        //相机解绑，标注，测量隐藏，视图
        for (SceneVo sceneVo : listAll) {
            if(!sceneVo.getBind() || (sceneVo.getStatus()!=null && sceneVo.getStatus() == 3)){
                fusionNumService.hideOrShow(sceneVo.getModelId(),sceneVo.getNum(),1);
            }else {
                fusionNumService.hideOrShow(sceneVo.getModelId(),sceneVo.getNum(),0);
            }
        }
        listAll.removeIf(sceneVo -> !sceneVo.getBind());

        //关联的三维模型
        if(param.getTypeList() == null ){
            List<String> numList = param.getTypeMap().get(3);
            if(numList!=null && numList.size() >0){
                List<Model> models = modelService.getListByModelIdStrs(numList);
                for (Model model : models) {
                    SceneVo sceneVo = new SceneVo();
                    sceneVo.setStatus(2);
                    BeanUtils.copyProperties(model,sceneVo);
                    listAll.add(sceneVo);
                }
            }
        }
        Set<String> snList = listAll.stream().filter(entity ->StringUtils.isNotBlank(entity.getSnCode()))
                .map(SceneVo::getSnCode).collect(Collectors.toSet());
        HashMap<String, TmDepartment> mapBySnCodes = tmCameraService.getMapBySnCodes(snList);
        for (SceneVo sceneVo : listAll) {
            if(StringUtils.isNotBlank(sceneVo.getSnCode())){
                TmDepartment tmDepartment = mapBySnCodes.get(sceneVo.getSnCode());
                if(tmDepartment != null){
                    sceneVo.setDeptId(tmDepartment.getId());
                    sceneVo.setDeptName(tmDepartment.getName());
                }
            }
        }

        Set<String> deptIdset = listAll.stream().filter(entity ->StringUtils.isNotBlank(entity.getDeptId())&& StringUtils.isBlank(entity.getDeptName()))
                .map(SceneVo::getDeptId).collect(Collectors.toSet());
        HashMap<String, TmDepartment> mapByDept = tmDepartmentService.getMapByDeptIds(deptIdset);
        HashMap<Integer,FusionNum> fusionNumHashMap = fusionNumService.getByCaseId(param.getCaseId());

        for (SceneVo sceneVo : listAll) {
            if(StringUtils.isNotBlank(sceneVo.getDeptId())){
                TmDepartment tmDepartment = mapByDept.get(sceneVo.getDeptId());
                if(tmDepartment != null){
                    sceneVo.setDeptName(tmDepartment.getName());
                }
            }
            if(sceneVo.getModelId() != null && fusionNumHashMap.get(sceneVo.getModelId()) != null){
                sceneVo.setInFusion(true);
            }

        }
        return listAll;
    }

    private void deleteNotInScene(List<String> numList,List<String> obNumList,Integer type,Integer caseId,List<SceneVo> sceneVos) {
        if(type == 3){  //上传的三维模型，无需处理
            return;
        }
        if(numList.size() >0){
            List<String> delNumList = new ArrayList<>();
            for (String num : numList) {
                if(!obNumList.contains(num)){
                    delNumList.add(num);
                }
            }
            List<String> delNumList2 = new ArrayList<>();
            for (SceneVo sceneVo : sceneVos) {
                if(sceneVo.getStatus() !=2 && sceneVo.getStatus() !=3 && sceneVo.getType().equals(type)){
                    delNumList2.add(sceneVo.getNum());
                }
            }
            caseNumService.deleteByNum(caseId,delNumList,type);
            fusionNumService.deleteByNumList(caseId,delNumList2,false,type);
        }
    }

    @Override
    public void addOrUpdate(CaseEntity param) {
        this.saveOrUpdate(param);
    }

    @Override
    public void addScene(CaseParam param) {
        if(param.getCaseId() == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        CaseEntity caseEntity = this.getById(param.getCaseId());
        if(caseEntity == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        caseNumService.addBatch(param.getCaseId(),param.getSceneNumParam());
    }

    @Override
    public void delete(Integer caseId) {
        if(caseId == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        //删除关联的场景
        caseNumService.deleteByCaseId(caseId);
        caseFilesService.deleteByCaseId(caseId);
        this.removeById(caseId);
    }



    @Override
    public List<CaseEntity> getByIds(List<Integer> caseIdIds) {
        LambdaQueryWrapper<CaseEntity> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(CaseEntity::getCaseId,caseIdIds);
        return this.list(wrapper);
    }

    @Override
    public CaseEntity getByTmProjectId(String projectId) {
        LambdaQueryWrapper<CaseEntity> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(CaseEntity::getTmProjectId,projectId);
        return this.getOne(wrapper);
    }

    @Override
    public void updateIdenTityStatus(Integer caseId, Integer status) {
        CaseEntity caseEntity = this.getById(caseId);
        if(caseEntity != null && StringUtils.isNotBlank(caseEntity.getTmProjectId())){
            tmProjectService.updateIdenTityStatus(caseEntity.getTmProjectId(),status);
        }
    }

    @Override
    public String getDeptId(Integer caseId) {
        CaseEntity caseEntity = this.getById(caseId);
        String deptId = caseEntity.getDeptId();
        if(caseEntity.getType() ==1){
            deptId = tmProjectService.getById(caseEntity.getTmProjectId()).getDeptId();
        }
        return deptId;
    }

    @Override
    public CaseVo getInfo(Integer caseId) {
        CaseEntity caseEntity = this.getById(caseId);
        if(caseEntity == null){
            return null;
        }
        CaseVo caseVo = new CaseVo();
        BeanUtil.copyProperties(caseEntity,caseVo);
        if(caseEntity.getTmProjectId() != null){
            TmProject tmProject = tmProjectService.getById(caseEntity.getTmProjectId());
            if(tmProject!= null && tmProject.getIsDelete()!=0){
                throw  new BusinessException(ResultCode.CASE_NOT_EXITS);
            }
            caseVo.setTmProject(tmProject);
            caseVo.setCaseTitle(tmProject.getProjectName());
        }
        return caseVo;
    }

    @Override
    public CaseEntity getKnumber(String kNumber) {
        LambdaQueryWrapper<CaseEntity> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(CaseEntity::getKNumber,kNumber);
        List<CaseEntity> list = this.list(wrapper);
        if(list != null && !list.isEmpty()){
            return list.get(0);
        }
        return null;
    }
}