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

package com.fdkankan.fusion.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.fdkankan.fusion.common.ResultCode;
import com.fdkankan.fusion.entity.CaseFusion;
import com.fdkankan.fusion.entity.FusionNum;
import com.fdkankan.fusion.entity.Model;
import com.fdkankan.fusion.entity.jsonEntity.Transform;
import com.fdkankan.fusion.exception.BusinessException;
import com.fdkankan.fusion.mapper.IFusionNumMapper;
import com.fdkankan.fusion.request.CaseParam;
import com.fdkankan.fusion.request.FusionParam;
import com.fdkankan.fusion.response.FusionNumVo;
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 java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 
 * @since 2022-08-04
 */
@Service
public class FusionNumServiceImpl extends ServiceImpl<IFusionNumMapper, FusionNum> implements IFusionNumService {

    @Autowired
    ICaseFusionService caseFusionService;
    @Autowired
    ICaseService caseService;
    @Autowired
    IModelService modelService;
    @Autowired
    IFusionMeterService fusionMeterService;
    @Autowired
    ICaseTagPointService caseTagPointService;
    @Autowired
    ICaseViewService caseViewService;

    @Override
    public List<FusionNum> getByNum(String num) {
        LambdaQueryWrapper<FusionNum> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(FusionNum::getModelId,num);
        return this.list(wrapper);
    }

    @Override
    public List<FusionNum> getListByFusionIdList(List<Integer> fusionIdList) {
        LambdaQueryWrapper<FusionNum> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(FusionNum::getFusionId,fusionIdList);
        wrapper.orderByDesc(FusionNum::getCreateTime);
        return this.list(wrapper);
    }

    @Override
    public List<FusionNumVo> getListByCaseId(Integer caseId, Integer fusionNumId,String token) {
        List<FusionNum> fusionNumList = new ArrayList<>();
        if(fusionNumId!=null){
            FusionNum fusionNum = this.getById(fusionNumId);
            if(fusionNum!=null){
                fusionNumList = Collections.singletonList(fusionNum);
            }
        }else {
            List<CaseFusion> fusionList = caseFusionService.getListByCaseId(caseId);
            if(fusionList.size()<=0){
                return new ArrayList<>();
            }
            List<Integer> fusionIdList = fusionList.parallelStream().map(CaseFusion::getFusionId).collect(Collectors.toList());
            fusionNumList = getListByFusionIdList(fusionIdList);
        }
        if(fusionNumList.size() <=0){
            return new ArrayList<>();
        }
        CaseParam param =new CaseParam();
        HashMap<Integer, List<String>> typeMap = this.getTypeMap(fusionNumList);
        param.setTypeMap(typeMap);
        param.setCaseId(caseId);
        List<SceneVo> sceneVos = caseService.sceneList(param, token);
        HashMap<Integer,SceneVo> sceneMap = new HashMap<>();
        sceneVos.forEach(entity -> sceneMap.put(entity.getModelId(),entity));

        List<FusionNumVo> numVoList = new ArrayList<>();
        for (FusionNum fusionNum : fusionNumList) {
            SceneVo sceneVo = sceneMap.get(fusionNum.getModelId());
            if(sceneVo == null ){
                continue;
            }
            if(sceneVo.getStatus() == null){
                sceneVo.setStatus(2);
            }
            FusionNumVo fusionNumVo = new FusionNumVo();
            BeanUtils.copyProperties(fusionNum,fusionNumVo);
            Transform transform = JSONObject.parseObject(fusionNum.getTransform(), Transform.class);
            fusionNumVo.setTransform(transform);
            fusionNumVo.setSceneData(sceneVo);
            numVoList.add(fusionNumVo);
        }
        return numVoList;
    }

    private HashMap<Integer, List<String>> getTypeMap( List<FusionNum> list) {
        HashMap<Integer,List<String>> typeMap = new HashMap<>();
        List<Integer> modelIds = list.parallelStream().map(FusionNum::getModelId).collect(Collectors.toList());
        List<Model> modelList = modelService.getListByModelIds(modelIds);
        for (Model model : modelList) {
            List<String> numList ;
            if(typeMap.get(model.getType()) == null){
                numList = new ArrayList<>();
            }else {
                numList = typeMap.get(model.getType());
            }
            String num = StringUtils.isEmpty(model.getNum())  ? model.getModelId().toString(): model.getNum();
            numList.add(num);
            typeMap.put(model.getType(),numList);
        }
        return typeMap;
    }

    @Override
    public FusionNumVo add(FusionParam param) {
        if(param.getModelId()==null || param.getCaseId() == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        Model model = modelService.getById(param.getModelId());
        if(model == null){
            throw new BusinessException(ResultCode.MODEL_NOT_EXIST);
        }
        List<CaseFusion> list = caseFusionService.getListByCaseId(param.getCaseId());
        CaseFusion caseFusion = null;
        if(list.size() <=0){
            caseFusion = new CaseFusion();
            caseFusion.setCaseId(param.getCaseId());
            caseFusionService.save(caseFusion);
            list.add(caseFusion);
        }
        caseFusion = list.get(0);
        FusionNum fusionNum = new FusionNum();
        BeanUtils.copyProperties(param,fusionNum);
        fusionNum.setFusionId(caseFusion.getFusionId());
        fusionNum.setTransform(JSONObject.toJSONString(param.getTransform()));
        this.save(fusionNum);
        List<FusionNumVo> numVoList = this.getListByCaseId(param.getCaseId(), fusionNum.getFusionNumId(), param.getToken());
        if(numVoList.size()<=0){
            throw new BusinessException(ResultCode.ERROR);
        }
        return numVoList.get(0);
    }

    @Override
    public void updateModel(FusionParam param) {
        if(param.getFusionNumId() == null){
            throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
        }
        LambdaUpdateWrapper<FusionNum> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(FusionNum::getFusionNumId,param.getFusionNumId());

        if(param.getTransform()!=null){
            wrapper.set(FusionNum::getTransform,JSONObject.toJSONString(param.getTransform()));
        }
        if(param.getOpacity()!=null){
            wrapper.set(FusionNum::getOpacity,param.getOpacity());
        }
        if(param.getBottom()!=null){
            wrapper.set(FusionNum::getBottom,param.getBottom());
        }
        if(param.getHide()!=null){
            wrapper.set(FusionNum::getHide,param.getHide());
        }
        this.update(wrapper);
    }

    @Override
    public void deleteByCaseId(Integer caseId) {
        List<CaseFusion> caseFusionList = caseFusionService.getListByCaseId(caseId);
        if(caseFusionList.size() >0){
            List<Integer> fusionIds = caseFusionList.parallelStream().map(CaseFusion::getFusionId).collect(Collectors.toList());
            if(fusionIds.size() >0){
                LambdaQueryWrapper<FusionNum> wrapper = new LambdaQueryWrapper<>();
                wrapper.in(FusionNum::getFusionId,fusionIds);
                this.remove(wrapper);
            }
        }
    }

    /**
     * 删除视图不存在的场景码
     */
    @Override
    public void deleteByNumList(Integer caseId,List<String> deleteNum,boolean del) {
        if(deleteNum.size() <=0){
            return;
        }
        List<CaseFusion> caseFusionList = caseFusionService.getListByCaseId(caseId);
        if(caseFusionList.size() >0){
            List<Integer> fusionIds = caseFusionList.parallelStream().map(CaseFusion::getFusionId).collect(Collectors.toList());
            if(fusionIds.size() >0){
                LambdaQueryWrapper<Model> wrapper = new LambdaQueryWrapper<>();
                wrapper.in(Model::getNum,deleteNum);
                List<Model> list = modelService.list(wrapper);
                LambdaQueryWrapper<Model> wrapper2 = new LambdaQueryWrapper<>();
                wrapper2.in(Model::getModelId,deleteNum);
                List<Model> list2 = modelService.list(wrapper);
                list.addAll(list2);
                if(list.size()<=0){
                    return;
                }
                List<Integer> modelIds = list.parallelStream().map(Model::getModelId).collect(Collectors.toList());
                LambdaQueryWrapper<FusionNum> deleteWr = new LambdaQueryWrapper<>();
                deleteWr.in(FusionNum::getFusionId,fusionIds);
                deleteWr.in(FusionNum::getModelId,modelIds);
                List<FusionNum> list1 = this.list(deleteWr);
                List<Integer> fusionNumIds = list1.parallelStream().map(FusionNum::getFusionNumId).collect(Collectors.toList());
                fusionMeterService.deleteByFusionNumIds(fusionNumIds);
                caseTagPointService.deleteByFusionNumIds(fusionNumIds);
                if(del){
                    this.remove(deleteWr);
                }
            }
        }
        caseViewService.deleteByNumList(caseId,deleteNum);
    }

    @Override
    public void deleteByModelId(Integer modelId) {
        LambdaQueryWrapper<FusionNum> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(FusionNum::getModelId,modelId);
        List<FusionNum> list = this.list(wrapper);
        List<Integer> fusionNunIds = list.parallelStream().map(FusionNum::getFusionNumId).collect(Collectors.toList());
        caseTagPointService.deleteByFusionNumIds(fusionNunIds);
        fusionMeterService.deleteByFusionNumIds(fusionNunIds);
        this.remove(wrapper);
    }

    @Override
    public void deleteById(Integer fusionNumId) {
        FusionNum fusionNum = this.getById(fusionNumId);
        if(fusionNum!=null){
            fusionMeterService.deleteByFusionNumIds(Arrays.asList(fusionNum.getFusionNumId()));
            caseTagPointService.deleteByFusionNumIds(Arrays.asList(fusionNum.getFusionNumId()));
            this.removeById(fusionNumId);
        }
    }

    @Override
    public void hideOrShow(Integer modelId, String num,Integer hide) {
        caseViewService.hideOrShow(num,hide);
        LambdaQueryWrapper<FusionNum> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(FusionNum::getModelId,modelId);
        List<FusionNum> list = this.list(wrapper);
        List<Integer> fusionNumIds = list.parallelStream().map(FusionNum::getFusionNumId).collect(Collectors.toList());
        fusionMeterService.hideOrShow(fusionNumIds,hide);
        caseTagPointService.hideOrShow(fusionNumIds,hide);
    }
}