tocc-sq/ruoyi-zhdd/src/main/java/com/ruoyi/zhdd/service/impl/IncidentTaskServiceImpl.java

package com.ruoyi.zhdd.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONArray;
import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.ruoyi.common.constant.Constants;
import com.ruoyi.common.core.mybatisplus.core.ServicePlusImpl;
import com.ruoyi.common.core.page.PagePlus;
import com.ruoyi.common.core.page.TableDataInfo;
import com.ruoyi.common.exception.ServiceException;
import com.ruoyi.common.utils.PageUtils;
import com.ruoyi.common.utils.RedisUtils;
import com.ruoyi.zhdd.domain.IncidentTask;
import com.ruoyi.zhdd.domain.IncidentUser;
import com.ruoyi.zhdd.domain.bo.IncidentTaskBo;
import com.ruoyi.zhdd.domain.bo.IncidentTasksBo;
import com.ruoyi.zhdd.domain.bo.MessagePushUser;
import com.ruoyi.zhdd.domain.vo.IncidentTaskVo;
import com.ruoyi.zhdd.mapper.IncidentTaskMapper;
import com.ruoyi.zhdd.service.IIncidentTaskService;
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;

/**
 * 事件处置流程Service业务层处理
 *
 * @author xitong
 * @date 2021-09-28
 */
@Service
@Slf4j
public class IncidentTaskServiceImpl extends ServicePlusImpl<IncidentTaskMapper, IncidentTask, IncidentTaskVo> implements IIncidentTaskService {

    @Override
    public IncidentTaskVo queryById(String id) {
        return getVoById(id);
    }

    @Override
    public TableDataInfo<IncidentTaskVo> queryPageList(IncidentTaskBo bo) {
        PagePlus<IncidentTask, IncidentTaskVo> result = pageVo(PageUtils.buildPagePlus(), buildQueryWrapper(bo));
        return PageUtils.buildDataInfo(result);
    }

    @Override
    public List<IncidentTaskVo> queryList(IncidentTaskBo bo) {
        return listVo(buildQueryWrapper(bo));
    }

    private LambdaQueryWrapper<IncidentTask> buildQueryWrapper(IncidentTaskBo bo) {
        Map<String, Object> params = bo.getParams();
        LambdaQueryWrapper<IncidentTask> lqw = Wrappers.lambdaQuery();
        lqw.eq(bo.getIncidentId() != null, IncidentTask::getIncidentId, bo.getIncidentId());
        return lqw;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Boolean insertByBo(IncidentTasksBo bo) {
        JSONObject jsonObject = new JSONObject();
        // 待删除事件用户关系的array
        JSONArray removeJsonArray = new JSONArray();
        // 待新增事件用户关系的array
        JSONArray saveJsonArray = new JSONArray();
        if (StrUtil.isNotBlank(bo.getId())) {
            // 更新操作
            // 先查询是否已经发送过
            IncidentTaskVo incidentTaskVo = this.queryById(bo.getId());
            if (incidentTaskVo == null) {
                throw new ServiceException("方案不存在！");
            }
            if ("1".equals(incidentTaskVo.getTaskSend())) {
                throw new ServiceException("该消息已发送，不能再次编辑！");
            }
            IncidentTask update = BeanUtil.toBean(bo, IncidentTask.class);
            update.setExprJson(JSONUtil.toJsonStr(bo.getMessagePushUsers()));
            updateById(update);
            jsonObject.set("des", "更新处置方案：" + bo.getTaskName());
            jsonObject.set("taskId", update.getId());
            // 校验原有的人员和新的人员的区别
            List<String> oldUserId = JSONUtil.toList(StrUtil.blankToDefault(incidentTaskVo.getExprJson(), "[]"), MessagePushUser.class).stream().map(MessagePushUser::getUserId).collect(Collectors.toList());
            List<String> newUserId = CollUtil.defaultIfEmpty(bo.getMessagePushUsers(), new ArrayList<>()).stream().map(MessagePushUser::getUserId).collect(Collectors.toList());

            // 1:通知消息。2：处置消息
            String oldSendFlag = StrUtil.equals(incidentTaskVo.getSendFlag(), "1") ? "1" : "2";
            String newSendFlag = StrUtil.equals(bo.getSendFlag(), "1") ? "1" : "2";

            List<String> removeUserId = CollUtil.subtractToList(oldUserId, newUserId);
            List<String> addUserId = CollUtil.subtractToList(newUserId, oldUserId);

            // 如果消息类型的变更，则直接将原来的人员删除，保存新的人员。否则按照比对来增删人员
            String removeSource;
            String addSource;
            if (oldSendFlag.equals(newSendFlag)) {
                if ("1".equals(newSendFlag)) {
                    removeSource = "7";
                    addSource = "7";
                } else {
                    removeSource = "3";
                    addSource = "3";
                }
            } else {
                removeSource = oldSendFlag;
                removeUserId = oldUserId;
                addSource = newSendFlag;
                addUserId = newUserId;
            }
            for (String userId : removeUserId) {
                // 删除关系
                IncidentUser remove = new IncidentUser();
                remove.setIncidentId(bo.getId());
                remove.setUserId(userId);
                remove.setSource(removeSource);
                removeJsonArray.add(remove);
            }
            for (String userId : addUserId) {
                IncidentUser save = new IncidentUser();
                save.setIncidentId(bo.getId());
                save.setUserId(userId);
                save.setSource(addSource);
                saveJsonArray.add(save);
            }

        } else {
            IncidentTask add = BeanUtil.toBean(bo, IncidentTask.class);
            add.setId(null);
            add.setExprJson(JSONUtil.toJsonStr(bo.getMessagePushUsers()));
            save(add);
            jsonObject.set("des", "新增处置方案：" + bo.getTaskName());
            jsonObject.set("taskId", add.getId());

            List<String> newUserId = CollUtil.defaultIfEmpty(bo.getMessagePushUsers(), new ArrayList<>()).stream().map(MessagePushUser::getUserId).collect(Collectors.toList());
            for (String userId : newUserId) {
                IncidentUser save = new IncidentUser();
                save.setIncidentId(bo.getId());
                save.setUserId(userId);
                save.setSource(StrUtil.equals(bo.getSendFlag(), "1") ? "1" : "2");
                saveJsonArray.add(save);
            }
        }
        // 发送消息(1-应急处置消息、2-应急处置待办、3-资源管理待办)
        jsonObject.set("incidentId", bo.getIncidentId());
        jsonObject.set("incidentStatus", 3);
        RedisUtils.publish(Constants.PROCESS_RECORD, jsonObject);

        if (removeJsonArray.size() > 0) {
            RedisUtils.publish(Constants.INCIDENT_USER_DELETE, removeJsonArray);
        }
        if (saveJsonArray.size() > 0) {
            RedisUtils.publish(Constants.INCIDENT_USER_BATCH, saveJsonArray);
        }

        return true;
    }

    /**
     * 事件方案发送
     *
     * @param bo
     * @return
     */
    @Override
    public boolean taskSend(IncidentTasksBo bo) {
        List<IncidentTask> list = this.list(Wrappers.<IncidentTask>lambdaQuery()
            .eq(IncidentTask::getTaskSend, "0")
            .and(a -> a.eq(StrUtil.isNotBlank(bo.getId()), IncidentTask::getId, bo.getId())
                .or()
                .eq(StrUtil.isNotBlank(bo.getIncidentId()), IncidentTask::getIncidentId, bo.getIncidentId()))
        );
        if (list != null && list.size() > 0) {
            for (IncidentTask incidentTask : list) {
                // 更新方案为已发送状态
                incidentTask.setTaskSend("1");
                this.updateById(incidentTask);

                RedisUtils.publish(Constants.NOTICE_PUSH, incidentTask.getSendFlag() + "B" + incidentTask.getId(), msg -> {
                    log.info("应急方案消息发送 => " + msg);
                });
            }
        }
        return true;
    }

    @Override
    public Boolean updateByBo(IncidentTaskBo bo) {
        IncidentTask update = BeanUtil.toBean(bo, IncidentTask.class);
        validEntityBeforeSave(update);
        return updateById(update);
    }

    @Override
    public List<IncidentTaskVo> listTaskInfo(String id) {
        List<IncidentTaskVo> incidentTaskVo = listVo(Wrappers.<IncidentTask>lambdaQuery().eq(IncidentTask::getIncidentId, id).orderByAsc(IncidentTask::getCreateTime));
        if (incidentTaskVo != null) {
            // 查询指令和人员
            for (IncidentTaskVo taskVo : incidentTaskVo) {
                if (StrUtil.isNotBlank(taskVo.getExprJson())) {
                    taskVo.setMessagePushUsers(JSONUtil.toList(taskVo.getExprJson(), MessagePushUser.class));
                }
            }
        }
        return incidentTaskVo;
    }

    /**
     * 复制旧的方案到新事件中
     *
     * @param oldId
     * @param newId
     * @return
     */
    @Override
    public boolean copyTask(String oldId, String newId) {
        // 查询旧的方案
        List<IncidentTaskVo> incidentTaskVos = listTaskInfo(oldId);
        if (incidentTaskVos != null && incidentTaskVos.size() > 0) {
            List<IncidentTask> incidentTasks = new ArrayList<>();
            for (IncidentTaskVo incidentTaskVo : incidentTaskVos) {
                IncidentTask incidentTask = new IncidentTask();
                incidentTask.setTaskName(incidentTaskVo.getTaskName());
                incidentTask.setIncidentId(newId);
                incidentTask.setSendFlag(incidentTaskVo.getSendFlag());
                incidentTasks.add(incidentTask);
            }
            saveAll(incidentTasks);
        }
        return true;
    }

    /**
     * 保存前的数据校验
     *
     * @param entity 实体类数据
     */
    private void validEntityBeforeSave(IncidentTask entity) {
        //TODO 做一些数据校验,如唯一约束
    }

    @Override
    public Boolean deleteWithValidByIds(Collection<String> ids, Boolean isValid) {
        if (isValid) {
            //TODO 做一些业务上的校验,判断是否需要校验
        }
        // 查询处置方案。默认这边只有一个id
        String id = ids.iterator().next();
        IncidentTaskVo incidentTaskVo = queryById(id);
        if (incidentTaskVo != null) {
            if ("1".equals(incidentTaskVo.getTaskSend())) {
                throw new ServiceException("该消息已发送，不能删除！");
            }
            JSONObject jsonObject = new JSONObject();
            jsonObject.set("des", "处置方案：" + incidentTaskVo.getTaskName() + "删除");
            jsonObject.set("incidentId", incidentTaskVo.getIncidentId());
            jsonObject.set("taskId", incidentTaskVo.getId());
            jsonObject.set("incidentStatus", 3);
            RedisUtils.publish(Constants.PROCESS_RECORD, jsonObject, msg -> {
                log.info("事件处置方案删除消息 => " + msg);
            });
        }
        return removeByIds(ids);
    }

}