fu-hsi-service/src/main/java/com/supervision/police/service/impl/ModelIndexServiceImpl.java

package com.supervision.police.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.lang.Assert;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.supervision.common.domain.R;
import com.supervision.common.utils.IPages;
import com.supervision.common.utils.StringUtils;
import com.supervision.police.domain.*;
import com.supervision.police.dto.AtomicData;
import com.supervision.police.dto.CaseAtomicIndexDTO;
import com.supervision.police.dto.CaseAtomicResultWrapper;
import com.supervision.police.dto.JudgeLogic;
import com.supervision.police.mapper.CasePersonMapper;
import com.supervision.police.mapper.ModelAtomicResultMapper;
import com.supervision.police.mapper.ModelIndexMapper;
import com.supervision.police.service.ComDictionaryService;
import com.supervision.police.service.ModelAtomicIndexService;
import com.supervision.police.service.ModelCaseService;
import com.supervision.police.service.ModelIndexService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 指标表(ModelIndex)表服务实现类
 *
 * @author qmy
 * @since 2024-07-05 09:20:10
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class ModelIndexServiceImpl extends ServiceImpl<ModelIndexMapper, ModelIndex> implements ModelIndexService {

    private final ComDictionaryService comDictionaryService;

    private final ModelIndexMapper modelIndexMapper;

    private final ModelAtomicIndexService modelAtomicIndexService;

    private final ModelCaseService modelCaseService;

    private final ModelAtomicResultMapper modelAtomicResultMapper;

    private final CasePersonMapper casePersonMapper;
    @Override
    @Transactional(transactionManager = "dataSourceTransactionManager",rollbackFor = Exception.class)
    public R<?> selectAll(ModelIndex modelIndex, Integer page, Integer size) {
        IPage<ModelIndex> iPage = new Page<>(page, size);
        LambdaQueryWrapper<ModelIndex> wrapper = Wrappers.lambdaQuery();
        wrapper.like(modelIndex.getName() != null, ModelIndex::getName, modelIndex.getName())
                .like(modelIndex.getShortName() != null, ModelIndex::getShortName, modelIndex.getShortName())
                .like(modelIndex.getRemark() != null, ModelIndex::getRemark, modelIndex.getRemark())
                .eq(StringUtils.isNotEmpty(modelIndex.getIndexType()), ModelIndex::getIndexType, modelIndex.getIndexType())
                .eq(StringUtils.isNotEmpty(modelIndex.getCaseType()), ModelIndex::getCaseType, modelIndex.getCaseType())
                .eq(ModelIndex::getDataStatus, "1");
        iPage  = modelIndexMapper.selectPage(iPage, wrapper);
        List<ModelIndex> records = iPage.getRecords();
        List<ComDictionary> dicts = comDictionaryService.list();
        for (ModelIndex index : records) {
            index.setIndexTypeName(comDictionaryService.getName(dicts, "index_type", index.getIndexType()));
            index.setCaseTypeName(comDictionaryService.getName(dicts, "case_type", index.getCaseType()));
            //原子指标
            String judgeLogic = index.getJudgeLogic();
            List<String> ids = new ArrayList<>();
            if (StringUtils.isNotEmpty(judgeLogic)) {
                List<JudgeLogic> logic = JSONUtil.toList(judgeLogic, JudgeLogic.class);
                for (JudgeLogic judge : logic) {
                    List<AtomicData> atomicData = judge.getAtomicData();
                    for (AtomicData atomic : atomicData) {
                        ids.add(atomic.getAtomicIndex());
                    }
                }
                List<ModelAtomicIndex> atomicIndexList = modelAtomicIndexService.selectBatchIds(ids);
                index.setAtomicIndexList(atomicIndexList);
            }
            index.setAtomicIndexNum(ids.size());
        }
        iPage.setRecords(records);
        return R.ok(IPages.buildDataMap(iPage));
    }

    @Override
    @Transactional(transactionManager = "dataSourceTransactionManager",rollbackFor = Exception.class)
    public R<?> addOrUpd(ModelIndex modelIndex) {
        int i = 0;
        if (StringUtils.isEmpty(modelIndex.getId())) {
            i = modelIndexMapper.insert(modelIndex);
        } else {
            i = modelIndexMapper.updateById(modelIndex);
        }
        if (i > 0) {
            return R.okMsg("保存成功");
        } else {
            return R.fail("保存失败");
        }
    }

    @Override
    @Transactional(transactionManager = "dataSourceTransactionManager",rollbackFor = Exception.class)
    public R<?> del(String id) {
        ModelIndex index = modelIndexMapper.selectById(id);
        index.setDataStatus(StringUtils.getUUID());
        int i = modelIndexMapper.updateById(index);
        if (i > 0) {
            return R.okMsg("删除成功");
        } else {
            return R.fail("删除失败");
        }
    }

    @Override
    @Transactional(transactionManager = "dataSourceTransactionManager",rollbackFor = Exception.class)
    public R<?> selectAllAtomic(ModelAtomicIndex modelAtomicIndex, Integer page, Integer size) {
        IPage<ModelAtomicIndex> iPage = new Page<>(page, size);
        iPage  = modelAtomicIndexService.selectAll(iPage, modelAtomicIndex);
        List<ModelAtomicIndex> records = iPage.getRecords();
        List<ComDictionary> dicts = comDictionaryService.list();
        for (ModelAtomicIndex index : records) {
            index.setCaseTypeName(comDictionaryService.getName(dicts, "case_type", index.getCaseType()));
            index.setIndexSourceName(comDictionaryService.getName(dicts, "index_source", index.getIndexSource()));
            index.setRecordTypeName(comDictionaryService.getName(dicts, "record_type", index.getRecordType()));
        }
        iPage.setRecords(records);
        return R.ok(IPages.buildDataMap(iPage));
    }

    @Override
    @Transactional(transactionManager = "dataSourceTransactionManager",rollbackFor = Exception.class)
    public R<?> addOrUpdAtomic(ModelAtomicIndex modelAtomicIndex) {
        int i = 0;
        if (StringUtils.isEmpty(modelAtomicIndex.getId())) {
            i = modelAtomicIndexService.getMapper().insert(modelAtomicIndex);
        } else {
            i = modelAtomicIndexService.getMapper().updateById(modelAtomicIndex);
        }
        if (i > 0) {
            return R.okMsg("保存成功");
        } else {
            return R.fail("保存失败");
        }
    }

    @Override
    @Transactional(transactionManager = "dataSourceTransactionManager",rollbackFor = Exception.class)
    public R<?> delAtomic(String id) {
        ModelAtomicIndex index = modelAtomicIndexService.getMapper().selectById(id);
        index.setDataStatus(StringUtils.getUUID());
        int i = modelAtomicIndexService.getMapper().updateById(index);
        if (i > 0) {
            return R.okMsg("删除成功");
        } else {
            return R.fail("删除失败");
        }
    }

    @Override
    @Transactional(transactionManager = "dataSourceTransactionManager",rollbackFor = Exception.class)
    public List<CaseAtomicIndexDTO> listCaseAtomicIndex(String caseId, String indexSource) {

        Assert.notEmpty(caseId, "案件id不能为空");
        ModelCase modelCase = modelCaseService.getById(caseId);
        Assert.notNull(modelCase, "案件不存在");
        String caseType = modelCase.getCaseType();
        Assert.notEmpty(caseType, "案件类型不能为空");
        List<CasePerson> casePersonList = casePersonMapper.selectList(Wrappers.lambdaQuery(CasePerson.class)
                .eq(CasePerson::getCaseId, caseId).eq(CasePerson::getRoleCode, "1"));
        Assert.notEmpty(casePersonList, "案件行为人不能为空!");
        String actorId = CollUtil.getFirst(casePersonList).getId();
        // 获取案件类型对应的指标
        List<ModelIndex> modelIndexList = modelIndexMapper.selectList(
                Wrappers.lambdaQuery(ModelIndex.class)
                        .eq(ModelIndex::getCaseType, caseType)
                        .eq(ModelIndex::getIndexType, indexSource).eq(ModelIndex::getDataStatus, "1"));
        if (CollUtil.isEmpty(modelIndexList)){
            return new ArrayList<>(1);
        }

        // 从指标中计算出所有原子指标id
        List<String> automicIndexIds = modelIndexList.stream().filter(modelIndex -> StrUtil.isNotEmpty(modelIndex.getJudgeLogic()))
                .map(modelIndex -> pickAtomicIndexIds(modelIndex.getJudgeLogic()))
                .flatMap(Collection::stream).distinct().toList();

        if (CollUtil.isEmpty(automicIndexIds)){
            return new ArrayList<>(1);
        }

        // 查询原子指标相关信息
        List<ModelAtomicIndex> modelAtomicIndexList = modelAtomicIndexService.listCaseAtomicIndex(automicIndexIds, caseType, indexSource);
        if (CollUtil.isEmpty(modelAtomicIndexList)){
            return new ArrayList<>(1);
        }
        Map<String, ModelAtomicIndex> modelAtomicIndexMap = modelAtomicIndexList.stream().collect(Collectors.toMap(ModelAtomicIndex::getId, v -> v, (v1, v2) -> v1));

        // 查询判定结果数据
        List<ModelAtomicResult> modelAtomicResults = modelAtomicResultMapper.selectList(
                Wrappers.lambdaQuery(ModelAtomicResult.class).eq(ModelAtomicResult::getCaseId, caseId)
                        .eq(ModelAtomicResult::getCasePersonId, actorId)
                        .in(ModelAtomicResult::getAtomicId, automicIndexIds));

        Map<String, ModelAtomicResult> modelAtomicResultMap = modelAtomicResults.stream()
                .filter(modelAtomicResult -> StrUtil.isNotEmpty(modelAtomicResult.getAtomicId())).collect(Collectors.toMap(ModelAtomicResult::getAtomicId, v -> v, (v1, v2) -> v1));
        // 以指标为基础数据，组装原子指标的值。然后把数据进行平铺
        return modelIndexList.stream().flatMap(modelIndex -> {
            String judgeLogic = modelIndex.getJudgeLogic();
            List<String> indexIds = pickAtomicIndexIds(judgeLogic);
            return indexIds.stream().map(indexId ->
                    new CaseAtomicIndexDTO(modelAtomicIndexMap.get(indexId), modelIndex, modelAtomicResultMap.get(indexId))).toList().stream();
        }).toList();
    }

    @Override
    @Transactional(transactionManager = "dataSourceTransactionManager",rollbackFor = Exception.class)
    public Boolean saveCaseAtomicResult(CaseAtomicResultWrapper caseAtomicResultWrapper) {

        Assert.notEmpty(caseAtomicResultWrapper.getCaseId(), "案件id不能为空！");
        ModelCase modelCase = modelCaseService.getById(caseAtomicResultWrapper.getCaseId());
        Assert.notNull(modelCase, "案件不存在！");
        // 设置行为人id
        List<CasePerson> casePersonList = casePersonMapper.selectList(Wrappers.lambdaQuery(CasePerson.class)
                .eq(CasePerson::getCaseId, modelCase.getId()).eq(CasePerson::getRoleCode, "1"));
        Assert.notEmpty(casePersonList, "案件行为人不能为空!");
        caseAtomicResultWrapper.setActorId(CollUtil.getFirst(casePersonList).getId());


        //清空人工评估结果
        removeCaseAtomicResult(caseAtomicResultWrapper.getCaseId(),modelCase.getCaseType(),
                caseAtomicResultWrapper.getActorId(),"1");

        // 保存原子评估结果
        caseAtomicResultWrapper.getCaseAtomicIndexList().stream().map(caseAtomicIndexDTO ->
                caseAtomicIndexDTO.toModelAtomicResult(
                        caseAtomicResultWrapper.getCaseId(), caseAtomicResultWrapper.getActorId())).toList()
                .forEach(modelAtomicResultMapper::insert);

        return true;
    }


    /**
     * 清空案件下的评估结果
     * @param caseId 案件id
     * @param caseType 案件类型
     * @param actorId 行为人id
     * @param indexSource 原子指标来源
     */
    private void  removeCaseAtomicResult(String caseId,String caseType, String actorId,String indexSource) {
        List<ModelAtomicIndex> modelAtomicIndexList = modelAtomicIndexService.listCaseAtomicIndex(null, caseType, indexSource);
        List<String> automicIndexIds = modelAtomicIndexList.stream().map(ModelAtomicIndex::getId).distinct().toList();
        modelAtomicResultMapper.delete(Wrappers.lambdaQuery(ModelAtomicResult.class)
                .eq(ModelAtomicResult::getCaseId, caseId)
                .eq(ModelAtomicResult::getCasePersonId, actorId)
                .in(CollUtil.isNotEmpty(automicIndexIds),ModelAtomicResult::getAtomicId, automicIndexIds));
    }
    /**
     * 从逻辑中获取原子指标id
     * @param judgeLogic 判断逻辑json字符串
     * @return 原子指标id(不重复)
     */
    private List<String> pickAtomicIndexIds(String judgeLogic) {
        List<String> ids = new ArrayList<>();
        List<JudgeLogic> logic = JSONUtil.toList(judgeLogic, JudgeLogic.class);
        for (JudgeLogic judge : logic) {
            List<AtomicData> atomicData = judge.getAtomicData();
            for (AtomicData atomic : atomicData) {
                if (!ids.contains(atomic.getAtomicIndex())){
                    ids.add(atomic.getAtomicIndex());
                }
            }
        }
        return ids;
   }
}