代码提交

liusheng

20 小时以前 ab2884ade73fed97d1e7d7daf4b9b5b6dee83fdd

 smartor/src/main/java/com/smartor/service/impl/PatMedInhospServiceImpl.java

@@ -1,16 +1,17 @@
package com.smartor.service.impl;

import com.ruoyi.othervisit.api.OtherVisitFacade;
import com.ruoyi.inhospvisit.api.InhospVisitFacade;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.core.type.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.ruoyi.common.core.domain.entity.SysDept;
import com.ruoyi.common.core.service.IConfigService;
import com.ruoyi.common.core.service.dto.PatMedReq;
import com.ruoyi.common.core.service.dto.PatMedRes;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.DtoConversionUtils;
import com.ruoyi.common.utils.SecurityUtils;
import com.ruoyi.common.utils.StringUtils;
import com.smartor.domain.*;
import com.smartor.domain.entity.ServiceSubtaskEntity;
import com.ruoyi.inhospvisit.domain.PatMedInhospDTO;
import com.smartor.mapper.*;
import com.smartor.service.IPatMedInhospService;
import lombok.extern.slf4j.Slf4j;
@@ -20,12 +21,36 @@
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import java.io.IOException;
import java.time.Instant;
import java.time.temporal.ChronoUnit;
import java.util.*;
import java.util.stream.Collectors;

import com.ruoyi.othervisit.domain.PatMedOperationItem;
import com.ruoyi.inhospvisit.domain.PatMedInhospVO;
import com.ruoyi.inhospvisit.domain.PatMedInhosp;
import com.ruoyi.common.core.domain.entity.PatArchive;
import com.ruoyi.task.domain.entity.ServiceSubtaskEntity;
import com.ruoyi.task.domain.ServiceSubtask;
import com.ruoyi.task.domain.ServiceTask;
import com.ruoyi.task.domain.ServiceTaskdept;
import com.ruoyi.task.domain.ServiceTaskdiag;
import com.ruoyi.task.domain.ServiceTaskoper;
import com.ruoyi.task.domain.ServiceTaskRule;
import com.ruoyi.task.domain.ServiceTaskSchedule;
import com.ruoyi.task.domain.ServiceTaskScheduleDetail;
import com.ruoyi.task.mapper.ServiceSubtaskMapper;
import com.ruoyi.task.mapper.ServiceTaskdeptMapper;
import com.ruoyi.task.mapper.ServiceTaskdiagMapper;
import com.ruoyi.task.mapper.ServiceTaskMapper;
import com.ruoyi.task.mapper.ServiceTaskoperMapper;
import com.ruoyi.task.mapper.ServiceTaskRuleMapper;
import com.ruoyi.task.mapper.ServiceTaskScheduleDetailMapper;
import com.ruoyi.task.mapper.ServiceTaskScheduleMapper;
import com.ruoyi.task.domain.ServiceSubtaskPreachform;
import com.ruoyi.task.common.ScheduleSubtaskBuilder;
import com.ruoyi.task.mapper.ServiceSubtaskPreachformMapper;
import com.ruoyi.patarchive.domain.PatArchiveImport;
import com.ruoyi.patarchive.mapper.PatArchiveImportMapper;
import com.ruoyi.patarchive.mapper.PatArchiveMapper;
/**
 * 患者住院记录Service业务层处理
 *
@@ -35,8 +60,15 @@
@Slf4j
@Service
public class PatMedInhospServiceImpl implements IPatMedInhospService {

    @Autowired
    private PatMedInhospMapper patMedInhospMapper;
    private InhospVisitFacade inhospVisitFacade;

    /**
     * 手术数据一律经 ruoyi-othervisit 的门面取用（跨模块数据访问原则）。
     */
    @Autowired
    private OtherVisitFacade otherVisitFacade;
    @Autowired
    private ServiceTaskdeptMapper serviceTaskdeptMapper;
    @Autowired
@@ -54,32 +86,21 @@
    @Autowired
    private ServiceSubtaskPreachformMapper serviceSubtaskPreachformMapper;
    @Autowired
    private PatMedOperationMapper patMedOperationMapper;
    @Autowired
    private PatMedOperationItemMapper patMedOperationItemMapper;
    @Autowired
    private ServiceTaskRuleMapper serviceTaskRuleMapper;

    @Value("${spring.profiles.active}")
    private String active;
    @Autowired
    private IConfigService iSysConfigService;
    private ServiceTaskScheduleMapper serviceTaskScheduleMapper;


    /**
     * 查询患者住院记录
     *
     * @param inhospid 患者住院记录主键
     * @return 患者住院记录
     */
    @Override
    public PatMedInhosp selectPatMedInhospByInhospid(Long inhospid) {
        return patMedInhospMapper.selectPatMedInhospByInhospid(inhospid);
    }
    @Autowired
    private ScheduleSubtaskBuilder scheduleSubtaskBuilder;
    @Autowired
    private ServiceTaskScheduleDetailMapper serviceTaskScheduleDetailMapper;

    @Override
    public List<PatMedInhosp> selectPatMedInhosp(PatMedInhosp patMedInhosp) {
        return patMedInhospMapper.selectPatMedInhosp(patMedInhosp);
        return inhospVisitFacade.selectPatMedInhosp(patMedInhosp);
    }

    /**
@@ -90,35 +111,110 @@
     */
    @Override
    public List<PatMedInhosp> selectPatMedInhospList(PatMedInhosp patMedInhosp) {
        if (patMedInhosp.getCry() == 0) {
        //入院床位排序只在「在院」查询（cry=0）下生效，其它查询一律忽略，保证原有排序不变
        patMedInhosp.setBedSort(normalizeBedSort(patMedInhosp.getCry(), patMedInhosp.getBedSort()));
        if (patMedInhosp.getCry() != null && patMedInhosp.getCry() == 0) {
            patMedInhosp.setDeptcodeList(patMedInhosp.getLeaveldeptcodes());
            patMedInhosp.setHospitaldistrictcodeList(patMedInhosp.getLeavehospitaldistrictcodes());
            patMedInhosp.setLeaveldeptcodes(null);
            patMedInhosp.setLeavehospitaldistrictcodes(null);
            patMedInhosp.setInhospstate("0");
        } else if (patMedInhosp.getCry() == 1) {
        } else if (patMedInhosp.getCry() != null && patMedInhosp.getCry() == 1) {
            patMedInhosp.setInhospstate("1");
        } else if (patMedInhosp.getCry() != null && patMedInhosp.getCry() == 2) {
            patMedInhosp.setInhospstate("2");
        } else if (patMedInhosp.getCry() != null && patMedInhosp.getCry() == 3) {
            patMedInhosp.setInhospstate("3");
        }

        List<PatMedInhosp> patMedInhospList = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
        for (PatMedInhosp patMedInhosp1 : patMedInhospList) {
            String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
            patMedInhosp1.setTagname(tagname);
        }
        List<PatMedInhosp> patMedInhospList = inhospVisitFacade.selectPatMedInhospList(patMedInhosp);
        fillTagname(patMedInhospList);
        return patMedInhospList;
    }

    @Override
    public Map<String, Integer> queryPersonCount(PatServiceCount patServiceCount) {
        if (patServiceCount.getInterval() == 1) {
            //周
        } else if (patServiceCount.getInterval() == 2) {
            //月
        } else if (patServiceCount.getInterval() == 3) {
            //年
    /**
     * 批量填充患者标签
     * <p>
     * 原实现是每行调一次 getTagnameBypatid，SQL 往返次数随 pageSize 线性增长；
     * 这里按 patid 去重后分批一次查回，结果与逐行查询完全一致（患者无标签时仍为 null）。
     *
     * @param patMedInhospList 待填充的住院记录，允许为空
     */
    private void fillTagname(List<PatMedInhosp> patMedInhospList) {
        if (CollectionUtils.isEmpty(patMedInhospList)) {
            return;
        }
        // LinkedHashSet 去重同时保持顺序，避免 IN 列表出现重复 patid
        Set<Long> patids = new LinkedHashSet<>();
        for (PatMedInhosp patMedInhosp : patMedInhospList) {
            if (patMedInhosp.getPatid() != null) {
                patids.add(patMedInhosp.getPatid());
            }
        }
        if (patids.isEmpty()) {
            return;
        }

        Map<Long, String> tagnameMap = new HashMap<>();
        List<Long> patidList = new ArrayList<>(patids);
        // 分片，防止 IN 参数过多
        int batchSize = 1000;
        for (int i = 0; i < patidList.size(); i += batchSize) {
            List<Long> batch = patidList.subList(i, Math.min(i + batchSize, patidList.size()));
            List<Map<String, Object>> rows = inhospVisitFacade.getTagnameByPatids(batch);
            if (CollectionUtils.isEmpty(rows)) {
                continue;
            }
            for (Map<String, Object> row : rows) {
                Object patid = row.get("patid");
                Object tagname = row.get("tagname");
                if (patid != null) {
                    tagnameMap.put(((Number) patid).longValue(), tagname == null ? null : tagname.toString());
                }
            }
        }

        for (PatMedInhosp patMedInhosp : patMedInhospList) {
            if (patMedInhosp.getPatid() != null) {
                patMedInhosp.setTagname(tagnameMap.get(patMedInhosp.getPatid()));
            }
        }
    }

    /**
     * 归一化入院床位排序参数
     * <p>
     * asc / 1 -> asc（床位正序），desc / 2 -> desc（床位倒序），其余（含不传）-> null（不排序）。
     * 只对「在院」患者查询（cry=0）生效，出院/转科等查询忽略该参数。
     *
     * @param cry     出入院标识：0入院 1出院 2转科 3预入院
     * @param bedSort 前端传入的床位排序值
     * @return 归一化后的排序值（asc / desc / null）
     */
    private String normalizeBedSort(Integer cry, String bedSort) {
        if (cry == null || cry != 0 || StringUtils.isEmpty(bedSort)) return null;
        String value = bedSort.trim().toLowerCase();
        if ("asc".equals(value) || "1".equals(value)) return "asc";
        if ("desc".equals(value) || "2".equals(value)) return "desc";
        return null;
    }

    @Override
    public List<PatMedInhospDTO> selectPatMedInhospByApplication(PatMedInhosp patMedInhosp) {
        List<PatMedInhosp> patMedInhosps = selectPatMedInhospList(patMedInhosp);
        if (!org.springframework.util.CollectionUtils.isEmpty(patMedInhosps)) {
            return null;
        }
        List<PatMedInhospDTO> patMedInhospDTOList = DtoConversionUtils.sourceToTarget(patMedInhosps, PatMedInhospDTO.class);
        for (PatMedInhospDTO pmd : patMedInhospDTOList) {
            ServiceSubtaskEntity serviceSubtask = new ServiceSubtaskEntity();
            serviceSubtask.setServiceType("4");
            serviceSubtask.setInhospid(pmd.getInhospid());
            List<ServiceSubtask> serviceSubtasks = serviceSubtaskMapper.selectServiceSubtaskList(serviceSubtask);
            if (CollectionUtils.isNotEmpty(serviceSubtasks)) pmd.setFinishFlag("1");
        }

        return patMedInhospDTOList;
    }

    /**
@@ -128,7 +224,7 @@
     * @return
     */
    public List<PatMedInhosp> selectPatMedInhospListByCondition(PatMedInhospVO patMedInhospVO) {
        return patMedInhospMapper.selectPatMedInhospListByCondition(patMedInhospVO);
        return inhospVisitFacade.selectPatMedInhospListByCondition(patMedInhospVO);
    }


@@ -152,20 +248,6 @@
    }

    /**
     * 查询出入院人次
     *
     * @param patMedReq
     * @return
     */
    @Override
    public PatMedRes selectPatMedInhospListCount(PatMedReq patMedReq) {
        PatMedRes patMedRes = null;
        // 获取当前登陆人的部门权限
        patMedRes = patMedInhospMapper.selectPatMedInhospCount(patMedReq);
        return patMedRes;
    }

    /**
     * 新增患者住院记录
     *
     * @param patMedInhosp 患者住院记录
@@ -175,7 +257,7 @@
    public int insertPatMedInhosp(PatMedInhosp patMedInhosp) {
        patMedInhosp.setCreateTime(DateUtils.getNowDate());
        patMedInhosp.setUpdateTime(DateUtils.getNowDate());
        return patMedInhospMapper.insertPatMedInhosp(patMedInhosp);
        return inhospVisitFacade.insertPatMedInhosp(patMedInhosp);
    }

    /**
@@ -187,283 +269,8 @@
    @Override
    public int updatePatMedInhosp(PatMedInhosp patMedInhosp) {
        patMedInhosp.setUpdateTime(DateUtils.getNowDate());
        return patMedInhospMapper.updatePatMedInhosp(patMedInhosp);
        return inhospVisitFacade.updatePatMedInhosp(patMedInhosp);
    }

    /**
     * 批量删除患者住院记录
     *
     * @param inhospids 需要删除的患者住院记录主键
     * @return 结果
     */
    @Override
    public int deletePatMedInhospByInhospids(Long[] inhospids) {
        return patMedInhospMapper.deletePatMedInhospByInhospids(inhospids);
    }

    /**
     * 删除患者住院记录信息
     *
     * @param inhospid 患者住院记录主键
     * @return 结果
     */
    @Override
    public int deletePatMedInhospByInhospid(Long inhospid) {
        return patMedInhospMapper.deletePatMedInhospByInhospid(inhospid);
    }

    /**
     * 删除患者住院记录信息
     *
     * @param inhospno 患者住院编码
     * @return 结果
     */
    @Override
    public int deletePatMedInhospByInhospno(String inhospno) {
        return patMedInhospMapper.deletePatMedInhospByInhospno(inhospno);
    }

    @Override
    public int dealOutHospInfo(String config) {
        //1.入院宣教
        String helibrarySwitch = iSysConfigService.selectConfigByKey("in.helibrary.switch");
        if (StringUtils.isNotEmpty(helibrarySwitch) && "2".equals(helibrarySwitch)) {
            PatMedInhosp inhosp = new PatMedInhosp();
            inhosp.setInDeptcheckFlag("0");
            inhosp.setInhospstate("0");
            inhosp.setFuflag("1");
            List<PatMedInhosp> inPatMedInhosps = patMedInhospMapper.selectPatMedInhospList(inhosp);

            //1.1 科室
            for (PatMedInhosp patMedInhosp1 : inPatMedInhosps) {
                //获取患者信息
                PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedInhosp1.getPatid());
                if (Objects.isNull(patArchive)) {
                    patMedInhosp1.setInDeptcheckFlag("2");
                    patMedInhosp1.setLongTaskReason("患者基本信息为空");
                    patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                    continue;
                }
                try {
                    //根据患者所在科室，获取该科室的入院长期宣教任务
                    ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
                    serviceTaskdept.setLongtask(1L);
                    serviceTaskdept.setDeptCode(patMedInhosp1.getDeptcode());
                    serviceTaskdept.setDeptType("1");
                    serviceTaskdept.setServiceType("17");
                    serviceTaskdept.setOrgid(patMedInhosp1.getOrgid());
                    List<ServiceTaskdept> serviceTaskdepts = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);
                    //如果部门模板为空（将deptIsNull设置为true）
                    if (CollectionUtils.isEmpty(serviceTaskdepts) || serviceTaskdepts.size() == 0) {
                        PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                        patMedInhosp1.setInDeptcheckFlag("2");
                        patMedInhosp1.setLongTaskReason(StringUtils.isNotEmpty(patMedInhosp.getLongTaskReason()) ? patMedInhosp.getLongTaskReason() + "该患者所在科室未配置入院长期宣教任务;" : "该患者所在科室未配置入院长期宣教任务;");
                        patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                    } else {
                        for (ServiceTaskdept serviceTaskdept1 : serviceTaskdepts) {
                            writeInSubTask(serviceTaskdept1.getTaskId(), true, patMedInhosp1, patArchive, 4, config);
                        }
                    }

                } catch (Exception e) {
                    log.error("人员入院科室处理出异常了：{}", e.getMessage());
                    patMedInhosp1.setInDeptcheckFlag("2");
                    patMedInhosp1.setLongTaskReason("人员入院科室处理出异常了：" + e.getMessage());
                    patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                }
            }


            //1.2 病区
            inhosp.setInDeptcheckFlag(null);
            inhosp.setInWardcheckFlag("0");
            List<PatMedInhosp> inPatMedInhospsWard = patMedInhospMapper.selectPatMedInhospList(inhosp);
            for (PatMedInhosp patMedInhosp1 : inPatMedInhospsWard) {
                //获取患者信息
                PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedInhosp1.getPatid());
                if (Objects.isNull(patArchive)) {
                    patMedInhosp1.setInDeptcheckFlag("2");
                    patMedInhosp1.setLongTaskReason("患者基本信息为空");
                    patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                    continue;
                }
                //根据患者所在病区，获取该病区的入院长期宣教任务（会出现一个问题，科室和病区发的同一个模板）
                ServiceTaskdept serviceTaskWard = new ServiceTaskdept();
                serviceTaskWard.setLongtask(1L);
                serviceTaskWard.setDeptCode(patMedInhosp1.getHospitaldistrictcode());
                serviceTaskWard.setDeptType("2");
                serviceTaskWard.setServiceType("17");
                serviceTaskWard.setOrgid(patMedInhosp1.getOrgid());
                List<ServiceTaskdept> serviceTaskWardList = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskWard);
                //如果部门模板为空（将deptIsNull设置为true）
                if (CollectionUtils.isEmpty(serviceTaskWardList) || serviceTaskWardList.size() == 0) {
                    PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                    patMedInhosp1.setInDeptcheckFlag("2");
                    patMedInhosp1.setLongTaskReason(patMedInhosp.getLongTaskReason() + "该患者所在病区未配置入院长期宣教任务;");
                    patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                } else {
                    for (ServiceTaskdept serviceTaskdept1 : serviceTaskWardList) {
                        writeInSubTask(serviceTaskdept1.getTaskId(), true, patMedInhosp1, patArchive, 5, config);
                    }
                }
            }
        }

        //2.出院随访 - 基于规则的任务生成
        addSubTaskByRule(config);
        //根据患者所在病区，获取该病区的长期任务,新华医院可以先不用根据病区和疾病来做
        if (!active.equals("xh")) {
            addOperationSubTask(config);
        }


        //获取未处理在院的数据(如果刚刚出院的患者数据的出院时间,在下面查询出的入院时间之前,那之前的出院患者的数据,也得停掉,因为又入院了)
        PatMedInhosp patMedInhosp = new PatMedInhosp();
        patMedInhosp.setDeptcheckFlag("0");
        patMedInhosp.setInhospstate("0");
        List<PatMedInhosp> patMedInhospList = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
        if (CollectionUtils.isNotEmpty(patMedInhospList) && patMedInhospList.size() > 0) {
            dealInHospInfo(patMedInhospList);
        }
        return 1;
    }

    /**
     * 多维度随访
     *
     * @param config
     * @return
     */
    public int dealOutHospInfoByDimension(String config) {
        // 一次性查出所有需要处理的出院患者（三个维度任意一个未完成）
        List<PatMedInhosp> patList = patMedInhospMapper.selectNeedProcessList();
        log.info("【统一扫描】待处理患者数：{}", patList.size());

        for (PatMedInhosp patMedInhosp1 : patList) {
            PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedInhosp1.getPatid());
            if (Objects.isNull(patArchive)) {
                // 三个维度都标记为失败
                markAllFlagsAsError(patMedInhosp1, "患者基本信息为空");
                continue;
            }

            // ── 维度1：科室 ──
            if ("0".equals(patMedInhosp1.getDeptcheckFlag())) {
                processTasksByDimension(patMedInhosp1, patArchive, config, 1);
            }

            // ── 维度2：病区 ──（新华医院跳过）
            if (!active.equals("xh") && "0".equals(patMedInhosp1.getWardcheckFlag())) {
                processTasksByDimension(patMedInhosp1, patArchive, config, 2);
            }

            // ── 维度3：疾病 ──（新华医院跳过）
            if (!active.equals("xh") && "0".equals(patMedInhosp1.getDiagcheckFlag())) {
                processTasksByDimension(patMedInhosp1, patArchive, config, 3);
            }
        }
        return 1;
    }

    /**
     * 按维度找到所有匹配长期任务，批量生成 subtask
     * type: 1=科室, 2=病区, 3=疾病
     */
    private void processTasksByDimension(PatMedInhosp patMedInhosp1, PatArchive patArchive, String config, int type) {
        List<Long> matchedTaskIds = findMatchingTaskIds(patMedInhosp1, type);

        if (CollectionUtils.isEmpty(matchedTaskIds)) {
            String reason = getDimensionReason(type);
            markFlagAsNoConfig(patMedInhosp1, type, reason);
            return;
        }

        // 一条 inhosp 记录 → 多个匹配任务 → 多条 subtask
        for (Long taskId : matchedTaskIds) {
            writeInSubTask(taskId, true, patMedInhosp1, patArchive, type, config);
        }
    }

    private String getDimensionReason(int type) {
        switch (type) {
            case 1: { // 科室
                return "未找到科室匹配的长期任务";
            }
            case 2: { // 病区
                return "未找到病区匹配的长期任务";
            }
            case 3: { // 疾病
                return "未找到疾病匹配的长期任务";
            }
        }
        return "多维长期任务-匹配类型为空";
    }

    private void markFlagAsNoConfig(PatMedInhosp patMedInhosp, int type, String reason) {
        switch (type) {
            case 1: { // 科室
                patMedInhosp.setDeptcheckFlag("2");
                patMedInhosp.setRemark(reason);
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp);
                break;
            }
            case 2: { // 病区
                patMedInhosp.setWardcheckFlag("2");
                patMedInhosp.setRemark(reason);
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp);
                break;
            }
            case 3: { // 疾病
                patMedInhosp.setDiagcheckFlag("2");
                patMedInhosp.setRemark(reason);
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp);
                break;
            }
        }

    }

    private void markAllFlagsAsError(PatMedInhosp patMedInhosp, String reason) {
        patMedInhosp.setDeptcheckFlag("2");
        patMedInhosp.setWardcheckFlag("2");
        patMedInhosp.setDiagcheckFlag("2");
        patMedInhosp.setRemark(reason);
        patMedInhospMapper.updatePatMedInhosp(patMedInhosp);
    }

    /**
     * 根据维度类型查询匹配的长期任务 ID 列表
     */
    private List<Long> findMatchingTaskIds(PatMedInhosp patMedInhosp1, int type) {
        switch (type) {
            case 1: { // 科室
                ServiceTaskdept query = new ServiceTaskdept();
                query.setLongtask(1L);
                query.setDeptCode(patMedInhosp1.getLeaveldeptcode());
                query.setDeptType("1");
                query.setOrgid(patMedInhosp1.getOrgid());
                return serviceTaskdeptMapper.selectServiceTaskdeptList(query).stream().map(ServiceTaskdept::getTaskId).collect(Collectors.toList());
            }
            case 2: { // 病区
                ServiceTaskdept query = new ServiceTaskdept();
                query.setLongtask(1L);
                query.setDeptCode(patMedInhosp1.getLeavehospitaldistrictcode());
                query.setDeptType("2");
                query.setOrgid(patMedInhosp1.getOrgid());
                return serviceTaskdeptMapper.selectServiceTaskdeptList(query).stream().map(ServiceTaskdept::getTaskId).collect(Collectors.toList());
            }
            case 3: { // 疾病
                if (StringUtils.isEmpty(patMedInhosp1.getLeaveicd10code())) return Collections.emptyList();
                ServiceTaskdiag query = new ServiceTaskdiag();
                query.setLongtask(1L);
                query.setIcd10code(patMedInhosp1.getLeaveicd10code());
                query.setOrgid(patMedInhosp1.getOrgid());
                return serviceTaskdiagMapper.selectServiceTaskdiagList(query).stream().map(ServiceTaskdiag::getTaskId).collect(Collectors.toList());
            }
        }
        return Collections.emptyList();
    }


    /**
     * 获取出院，住院，门诊服务人次
@@ -479,9 +286,9 @@

    @Override
    public List<PatMedInhosp> getDocAndPat(PatMedInhosp patMedInhosp) {
        List<PatMedInhosp> patMedInhospList = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
        List<PatMedInhosp> patMedInhospList = inhospVisitFacade.selectPatMedInhospList(patMedInhosp);
        for (PatMedInhosp patMedInhosp1 : patMedInhospList) {
            String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
            String tagname = inhospVisitFacade.getTagnameBypatid(patMedInhosp1.getPatid());
            patMedInhosp1.setTagname(tagname);
        }
        if (StringUtils.isNotEmpty(patMedInhosp.getPatname()) || StringUtils.isNotEmpty(patMedInhosp.getNurseName()) || StringUtils.isNotEmpty(patMedInhosp.getDrname())) {
@@ -526,7 +333,7 @@
     * @param check         是否需要校验
     * @param patMedInhosp1 病人出入院信息
     * @param patArchive    病人信息
     * @param type          随访类型(1-科室，2-病区，3-疾病 4-入院科室 5-入院病区)
     * @param type          随访类型(0-宣教，1-科室，2-病区，3-疾病 4-入院科室 5-入院病区)
     * @param config        配置信息 visit.early.day
     */
    //将患者放到subtask中
@@ -540,31 +347,38 @@
        List<ServiceTask> serviceTasks = serviceTaskMapper.selectServiceTaskList(st);
        ServiceTask serviceTask = null;
        if (CollectionUtils.isEmpty(serviceTasks)) {
            if (type == 0) {
                log.info("该患者药品宣教长期任务不存在,任务ID为：{}", taskid);
                patMedInhosp1.setMedcheckFlag("2");
                patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者药品宣教长期任务不存在,任务ID为:" + taskid);
                inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
                return;
            }
            if (type == 1) {
                log.info("该患者出院随访长期任务不存在,任务ID为：{}", taskid);
                patMedInhosp1.setDeptcheckFlag("2");
                patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者离院科室长期任务不存在,任务ID为:" + taskid);
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
                return;
            } else if (type == 2) {
                patMedInhosp1.setWardcheckFlag("2");
                patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者离院病区长期任务不存在,任务ID为:" + taskid);
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
                return;
            } else if (type == 3) {
                patMedInhosp1.setDiagcheckFlag("2");
                patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者疾病长期任务不存在,任务ID为:" + taskid);
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
                return;
            } else if (type == 4) {
                patMedInhosp1.setInDeptcheckFlag("2");
                patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者入院科室长期任务不存在,任务ID为:" + taskid);
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
                return;
            } else if (type == 5) {
                patMedInhosp1.setInWardcheckFlag("2");
                patMedInhosp1.setLongTaskReason(longTaskReason + " & 该患者入院病区长期任务不存在,任务ID为:" + taskid);
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
                return;
            }
        } else {
@@ -639,7 +453,7 @@
                            //再入院逻辑
                            //景宁 出院首次（7天）随访一定要做
                            boolean firstVisit = false;
                            if (orgId.equals("47255004333112711A1001") && serviceSubtask1.getVisitCount() != null && serviceSubtask1.getVisitCount() == 1) {
                            if (orgId.equals("47255004333112711A1001")) {
                                firstVisit = true;
                            }
                            if (!firstVisit) {
@@ -718,7 +532,7 @@
                addServiceSubtaskPreachform(serviceSubtask, null);
            }

            //将check_flag改成1（已处理）
            //将 check_flag 改成 1（已处理）
            if (i == 1) {
                PatMedInhosp patMedInhosp2 = new PatMedInhosp();
                patMedInhosp2.setInhospid(patMedInhosp1.getInhospid());
@@ -727,7 +541,7 @@
                if (type == 3) patMedInhosp2.setDiagcheckFlag("1");
                if (type == 4) patMedInhosp2.setInDeptcheckFlag("1");
                if (type == 5) patMedInhosp2.setInWardcheckFlag("1");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp2);
                inhospVisitFacade.updatePatMedInhosp(patMedInhosp2);
            } else {
                //生成子任务失败，
                log.info("生成子任务失败serviceSubtask的taskid为：{},patid为：{}", serviceSubtask.getTaskid(), serviceSubtask.getPatid());
@@ -739,7 +553,7 @@
                if (type == 4) patMedInhosp2.setInDeptcheckFlag("2");
                if (type == 5) patMedInhosp2.setInWardcheckFlag("2");
                patMedInhosp2.setRemark("生成子任务失败 " + type);
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp2);
                inhospVisitFacade.updatePatMedInhosp(patMedInhosp2);
            }
        } catch (Exception e) {
            //出错回滚事务
@@ -749,8 +563,9 @@
            if (type == 1) patMedInhosp2.setDeptcheckFlag("2");
            if (type == 2) patMedInhosp2.setWardcheckFlag("2");
            if (type == 3) patMedInhosp2.setDiagcheckFlag("2");
            if (type == 0) patMedInhosp2.setMedcheckFlag("2");
            patMedInhosp2.setRemark("生成子任务报错回滚 " + type);
            patMedInhospMapper.updatePatMedInhosp(patMedInhosp2);
            inhospVisitFacade.updatePatMedInhosp(patMedInhosp2);
            e.printStackTrace();
        }
    }
@@ -776,48 +591,48 @@
        if (CollectionUtils.isEmpty(serviceTasks)) {
            log.info("该手术对应手术等级的长期任务不存在,任务ID为：{}", taskid);
            patMedOperationItem.setOpercheckFlag("2");
            patMedOperationItem.setLongTaskReason(longTaskReason + " & 该手术对应手术等级的长期任务不存在,任务ID为:" + taskid);
            patMedOperationItemMapper.insertPatMedOperationItem(patMedOperationItem);
            patMedOperationItem.setLongTaskReason(" & 该手术对应手术等级的长期任务不存在,任务ID为:" + taskid +";");
            otherVisitFacade.updateOperationItem(patMedOperationItem);
            return;
        } else {
            serviceTask = serviceTasks.get(0);
        }
        if (Objects.isNull(patMedOperationItem.getOpid())) {
            return;
        }
        if (Objects.isNull(patMedOperationItem.getOplevelcode())) {
            return;
        }
        PatMedOperation patMedOperationVo = new PatMedOperation();
        PatMedOperation patMedOperation = new PatMedOperation();
        patMedOperationVo.setOpid(patMedOperationItem.getOpid());
        List<PatMedOperation> patMedOperationList = patMedOperationMapper.selectPatMedOperationList(patMedOperationVo);
        if (CollectionUtils.isEmpty(patMedOperationList)) {
        if (Objects.isNull(patMedOperationItem.getPatid())) {
            return;
        }else {
            patMedOperation = patMedOperationList.get(0);
        }
        PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedOperation.getPatid());
        PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedOperationItem.getPatid());
        if (Objects.isNull(patArchive)) {
            return;
        }
        PatMedInhosp patMedInhosp = new PatMedInhosp();
        patMedInhosp.setPatid(patMedOperation.getPatid());
        patMedInhosp.setPatid((patMedOperationItem.getPatid()));
        patMedInhosp.setInhospstate("1");
        patMedInhosp.setFuflag("1");
        List<PatMedInhosp> patMedInhospList = patMedInhospMapper.selectPatMedInhospList(patMedInhosp);
        //手术随访
        if(!active.equals("hzszlyy")){
            patMedInhosp.setSerialnum(patMedOperationItem.getSerialnum());
        }
        List<PatMedInhosp> patMedInhospList = inhospVisitFacade.selectPatMedInhospList(patMedInhosp);

        if (CollectionUtils.isEmpty(patMedInhospList)) {
            return;
        }

        //封装serviceSubtask
        ServiceSubtask serviceSubtask = boxedServiceSubtaskForOp(serviceTask, patMedInhospList.get(0), patMedOperation, patMedOperationItem, patArchive, config);
        if (ObjectUtils.isEmpty(serviceSubtask)) {
        ServiceSubtask serviceSubtask = boxedServiceSubtaskForOp(serviceTask, patMedInhospList.get(0), patMedOperationItem, patArchive, config);
        if (ObjectUtils.isEmpty(serviceSubtask) || Objects.isNull(serviceSubtask.getTaskid())) {
            return;
        }
        serviceSubtask.setVisitDeptCode(patMedOperation.getReqdeptcode());
        serviceSubtask.setVisitDeptName(patMedOperation.getReqdeptname());
        if (StringUtils.isNotEmpty(patMedOperationItem.getLeaveldeptcode())) {
            serviceSubtask.setVisitDeptCode(patMedOperationItem.getLeaveldeptcode());
            serviceSubtask.setVisitDeptName(patMedOperationItem.getLeaveldeptname());
        } else {
            serviceSubtask.setVisitDeptCode(patMedOperationItem.getLeavehospitaldistrictcode());
            serviceSubtask.setVisitDeptName(patMedOperationItem.getLeavehospitaldistrictname());
        }
        //记录insertServiceSubtask语句返回状态
        Integer i = 0;
        try {
@@ -875,25 +690,28 @@
                PatMedOperationItem patMedOperationItem2 = new PatMedOperationItem();
                patMedOperationItem2.setId(patMedOperationItem.getId());
                patMedOperationItem2.setOpercheckFlag("1");
                patMedOperationItemMapper.updatePatMedOperationItem(patMedOperationItem2);
                otherVisitFacade.updateOperationItem(patMedOperationItem2);
            } else {
                //生成子任务失败，
                log.info("生成子任务失败serviceSubtask的taskid为：{},patid为：{}", serviceSubtask.getTaskid(), serviceSubtask.getPatid());
                PatMedOperationItem patMedOperationItem2 = new PatMedOperationItem();
                patMedOperationItem2.setId(patMedOperationItem.getId());
                patMedOperationItem2.setOpercheckFlag("2");
                patMedOperationItem2.setRemark("生成子任务失败 4");
                patMedOperationItemMapper.updatePatMedOperationItem(patMedOperationItem2);
                patMedOperationItem2.setLongTaskReason("生成子任务失败 4;");
                patMedOperationItem2.setUpdateTime(new Date());
                otherVisitFacade.updateOperationItem(patMedOperationItem2);
            }
        } catch (Exception e) {
            //出错回滚事务

            log.info("生成子任务报错回滚sserviceSubtask的taskid为：{},patid为：{}", serviceSubtask.getTaskid(), serviceSubtask.getPatid());
            log.error("生成子任务报错回滚sserviceSubtask的taskid为：{},patid为：{},手术详情ID为：{}",
                    serviceSubtask.getTaskid(), serviceSubtask.getPatid(), patMedOperationItem.getId(), e);
            PatMedOperationItem patMedOperationItem2 = new PatMedOperationItem();
            patMedOperationItem2.setId(patMedOperationItem.getId());
            patMedOperationItem2.setOpercheckFlag("2");
            patMedOperationItem2.setRemark("生成子任务报错回滚 4");
            patMedOperationItemMapper.updatePatMedOperationItem(patMedOperationItem2);
            patMedOperationItem2.setUpdateTime(new Date());
            patMedOperationItem2.setLongTaskReason("生成子任务报错回滚 4;");
            otherVisitFacade.updateOperationItem(patMedOperationItem2);
            e.printStackTrace();
        }
    }
@@ -901,6 +719,10 @@
    private Integer addServiceSubtaskPreachform(ServiceSubtask serviceSubtask, String sendstate) {
        //将preachformDesc的json对象，放到list集合中
        ServiceTask serviceTask = serviceTaskMapper.selectServiceTaskByTaskid(serviceSubtask.getTaskid());
        if (Objects.isNull(serviceTask)) {
            log.error("addServiceSubtaskPreachform taskid={} 查不到任务，跳过preachform子表生成", serviceSubtask.getTaskid());
            return 0;
        }
        String preachformDesc = serviceTask.getPreachformDesc();

        ObjectMapper objectMapper = new ObjectMapper();
@@ -911,6 +733,11 @@
                });
            } catch (JsonProcessingException e) {
                log.error("preachform转List<ServiceSubtaskPreachform>报错了：{}", e.getMessage());
            }
            if (CollectionUtils.isEmpty(serviceSubtaskPreachformList)) {
                log.error("preachformDesc解析后为空，跳过preachform子表生成，taskid为：{}，preachformDesc为：{}",
                        serviceSubtask.getTaskid(), preachformDesc);
                return 0;
            }
            for (ServiceSubtaskPreachform serviceSubtaskPreachform : serviceSubtaskPreachformList) {
                serviceSubtaskPreachform.setTaskid(serviceSubtask.getTaskid());
@@ -935,13 +762,16 @@


    //封装serviceSubtask
    private ServiceSubtask boxedServiceSubtask(ServiceTask serviceTask, PatMedInhosp patMedInhosp1, PatArchive patArchive, String config, Integer type) {
    @Override
    public ServiceSubtask boxedServiceSubtask(ServiceTask serviceTask, PatMedInhosp patMedInhosp1, PatArchive patArchive, String config, Integer type) {
        //增加serviceTask判空
//        if(Objects.isNull(serviceTask)){
//            return null;
//        }
        ServiceSubtask serviceSubtask = DtoConversionUtils.sourceToTarget(serviceTask, ServiceSubtask.class);
        serviceSubtask.setTaskid(serviceTask.getTaskid());
        serviceSubtask.setOrgid(serviceTask.getOrgid());
        serviceSubtask.setCampusid(serviceTask.getCampusid());
        if (StringUtils.isNotEmpty(serviceTask.getLibtemplateid()))
            serviceSubtask.setLibtemplateid(Long.valueOf(serviceTask.getLibtemplateid()));
        serviceSubtask.setNurseId(patMedInhosp1.getNurseId());
@@ -949,14 +779,14 @@
        serviceSubtask.setInhospid(patMedInhosp1.getInhospid());
        serviceSubtask.setDrcode(patMedInhosp1.getDrcode());
        serviceSubtask.setDrname(patMedInhosp1.getDrname());
        serviceSubtask.setDeptcode(patMedInhosp1.getLeaveldeptcode());
        serviceSubtask.setDeptname(patMedInhosp1.getLeaveldeptname());
        serviceSubtask.setLeaveldeptcode(patMedInhosp1.getLeaveldeptcode());
        serviceSubtask.setLeaveldeptname(patMedInhosp1.getLeaveldeptname());
        serviceSubtask.setLeavehospitaldistrictcode(patMedInhosp1.getLeavehospitaldistrictcode());
        serviceSubtask.setLeavehospitaldistrictname(patMedInhosp1.getLeavehospitaldistrictname());
        if (type == 4 || type == 5) {
            //设置入院的
            serviceSubtask.setDeptcode(patMedInhosp1.getDeptcode());
            serviceSubtask.setDeptname(patMedInhosp1.getDeptname());
            serviceSubtask.setLeaveldeptcode(patMedInhosp1.getDeptcode());
            serviceSubtask.setLeaveldeptname(patMedInhosp1.getDeptname());
            serviceSubtask.setLeavehospitaldistrictcode(patMedInhosp1.getHospitaldistrictcode());
            serviceSubtask.setLeavehospitaldistrictname(patMedInhosp1.getHospitaldistrictname());
        }
@@ -973,6 +803,7 @@
        serviceSubtask.setSex(patArchive.getSex());
        serviceSubtask.setAge(patArchive.getAge());
        serviceSubtask.setSendstate(2L);
        serviceSubtask.setCampusid(patMedInhosp1.getCampusid());
        serviceSubtask.setManagementDoctor(patMedInhosp1.getManagementDoctor());
        serviceSubtask.setManagementDoctorCode(patMedInhosp1.getManagementDoctorCode());
        serviceSubtask.setStarttime(patMedInhosp1.getStarttime());
@@ -1000,7 +831,7 @@
            if (type != 4 && type != 5) {
                patMedInhosp1.setDeptcheckFlag("2");
                patMedInhosp1.setRemark(patMedInhosp1.getRemark() + "& 该患者疾病出院时间为空,出院记录ID为:" + patMedInhosp1.getInhospid());
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
                //如果出院时间为空，则返回一个新对象
                return new ServiceSubtask();
            }
@@ -1049,18 +880,22 @@
    }

    //封装serviceSubtask
    private ServiceSubtask boxedServiceSubtaskForOp(ServiceTask serviceTask, PatMedInhosp patMedInhosp1, PatMedOperation patMedOperation, PatMedOperationItem patMedOperationItem, PatArchive patArchive, String config) {
    private ServiceSubtask boxedServiceSubtaskForOp(ServiceTask serviceTask, PatMedInhosp patMedInhosp1, PatMedOperationItem patMedOperationItem, PatArchive patArchive, String config) {
        ServiceSubtask serviceSubtask = DtoConversionUtils.sourceToTarget(serviceTask, ServiceSubtask.class);
        serviceSubtask.setTaskid(serviceTask.getTaskid());
        serviceSubtask.setOrgid(serviceTask.getOrgid());
        serviceSubtask.setCampusid(serviceTask.getCampusid());
        if (StringUtils.isNotEmpty(serviceTask.getLibtemplateid()))
            serviceSubtask.setLibtemplateid(Long.valueOf(serviceTask.getLibtemplateid()));
        serviceSubtask.setNurseId(patMedOperation.getNurseId());
        serviceSubtask.setNurseName(patMedOperation.getNurseName());
//        serviceSubtask.setInhospid(patMedInhosp.getInhospid());
        serviceSubtask.setDrcode(patMedOperation.getDrcode());
        serviceSubtask.setDrname(patMedOperation.getDrname());
        serviceSubtask.setDeptcode(patMedOperation.getDeptcode());
        serviceSubtask.setDeptname(patMedOperation.getDeptname());
        serviceSubtask.setNurseId(patMedInhosp1.getNurseId());
        serviceSubtask.setNurseName(patMedInhosp1.getNurseName());
        serviceSubtask.setInhospid(patMedInhosp1.getInhospid());
        serviceSubtask.setDrcode(patMedInhosp1.getDrcode());
        serviceSubtask.setDrname(patMedInhosp1.getDrname());
        serviceSubtask.setLeaveldeptcode(patMedInhosp1.getLeaveldeptcode());
        serviceSubtask.setLeaveldeptname(patMedInhosp1.getLeaveldeptname());
        serviceSubtask.setLeavehospitaldistrictcode(patMedInhosp1.getLeavehospitaldistrictcode());
        serviceSubtask.setLeavehospitaldistrictname(patMedInhosp1.getLeavehospitaldistrictname());

        serviceSubtask.setTemplateid(serviceTask.getTemplateid());
        serviceSubtask.setTemplatename(serviceTask.getTemplatename());
@@ -1072,35 +907,36 @@
        serviceSubtask.setSex(patArchive.getSex());
        serviceSubtask.setAge(patArchive.getAge());
        serviceSubtask.setSendstate(2L);
        serviceSubtask.setManagementDoctor(patMedOperation.getDrname());
        serviceSubtask.setManagementDoctorCode(patMedOperation.getDrcode());
//        serviceSubtask.setStarttime(patMedInhosp.getStarttime());
//        serviceSubtask.setEndtime(patMedInhosp.getEndtime());
        serviceSubtask.setManagementDoctor(patMedInhosp1.getDrname());
        serviceSubtask.setManagementDoctorCode(patMedInhosp1.getDrcode());

        serviceSubtask.setStarttime(patMedInhosp1.getStarttime());
        serviceSubtask.setEndtime(patMedInhosp1.getEndtime());

        serviceSubtask.setServiceType(serviceTask.getServiceType());
        serviceSubtask.setPreachform(serviceTask.getPreachform());
        serviceSubtask.setHospType("2");
        serviceSubtask.setCreateTime(new Date());
        serviceSubtask.setUpdateTime(new Date());
        serviceSubtask.setCreateBy(patMedOperation.getNurseName());
//        serviceSubtask.setLeavehospitaldistrictcode(patArchive.getLeavehospitaldistrictcode());
//        serviceSubtask.setLeavehospitaldistrictname(patArchive.getLeavehospitaldistrictname());
        serviceSubtask.setCreateBy(patMedInhosp1.getNurseName());
        serviceSubtask.setOperationItemId(patMedOperationItem.getId());
        serviceSubtask.setUpdateBy(serviceTask.getUpdateBy());
        serviceSubtask.setUpdateTime(new Date());

        //todo
        //设置发送时间
        if (serviceTask.getSendDay() == null) serviceTask.setSendDay(1L);
        Date newDate = null;
        if (!Objects.isNull(patMedInhosp1.getEndtime())) {
            newDate = addDays(patMedInhosp1.getEndtime(), serviceTask.getSendDay().intValue());
        } else {
            patMedInhosp1.setDeptcheckFlag("2");
            patMedInhosp1.setRemark(patMedInhosp1.getRemark() + "& 该患者手术出院时间为空,出院记录ID为:" + patMedInhosp1.getInhospid());
            patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
            patMedOperationItem.setOpercheckFlag("2");
            patMedOperationItem.setLongTaskReason("该患者手术出院时间为空,手术详情ID为:" + patMedOperationItem.getId() + ";");
            otherVisitFacade.updateOperationItem(patMedOperationItem);
//            patMedInhosp1.setDeptcheckFlag("2");
//            patMedInhosp1.setRemark(patMedInhosp1.getRemark() + "& 该患者手术出院时间为空,出院记录ID为:" + patMedInhosp1.getInhospid());
//            inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
            //如果出院时间为空，则返回一个新对象
            return new ServiceSubtask();
            return null;
        }
        serviceSubtask.setLongSendTime(newDate);
        serviceSubtask.setVisitTime(newDate);
@@ -1157,7 +993,7 @@
                        }
                        //景宁 出院首次（7天）随访一定要做
                        boolean firstVisit = false;
                        if (serviceSubtask1.getOrgid().equals("47255004333112711A1001") && serviceSubtask1.getVisitCount() != null && serviceSubtask1.getVisitCount() == 1) {
                        if (serviceSubtask1.getOrgid().equals("47255004333112711A1001")) {
                            firstVisit = true;
                        }
                        if (!firstVisit) {
@@ -1176,272 +1012,6 @@
                }
            } catch (Exception e) {
                log.error("入院数据信息出异常了：{},{}", patMedInhosp1, e.getMessage());
            }
        }
    }

    @Override
    public void addOperationSubTask(String config) {
        //            手术随访
        PatMedOperationItem pmoi = new PatMedOperationItem();
        //获取需要出院疾病随访，未处理的数据
        pmoi.setOpercheckFlag("0");
        pmoi.setMainFlag("1");

        List<PatMedOperationItem> patMedOperationItems = patMedOperationItemMapper.selectPatMedOperationItemList(pmoi);
        log.info("dealOutHospInfo需要处理的出院手术患者信息：{}", CollectionUtils.isNotEmpty(patMedOperationItems) ? patMedOperationItems.size() : null);

        for (PatMedOperationItem opItem : patMedOperationItems) {

            try {
                if (StringUtils.isEmpty(opItem.getOplevelcode())) {
                    continue;
                }
                // 根据患者的疾病，获取该疾病的长期任务
                ServiceTaskoper serviceTaskoper = new ServiceTaskoper();
                serviceTaskoper.setLongtask(1L);
                serviceTaskoper.setOrgid(opItem.getOrgid());
                serviceTaskoper.setOplevelcode(opItem.getOplevelcode());

                List<ServiceTaskoper> serviceTaskopers = serviceTaskoperMapper.selectServiceTaskoperList(serviceTaskoper);
                //如果部门模板为空（将deptIsNull设置为true）
                if (CollectionUtils.isEmpty(serviceTaskopers) || serviceTaskopers.size() == 0) {
                    PatMedOperationItem patMedOperationItem = patMedOperationItemMapper.selectPatMedOperationItemById(opItem.getId());
                    patMedOperationItem.setOpercheckFlag("2");
                    patMedOperationItem.setLongTaskReason(patMedOperationItem.getLongTaskReason() + "所患的手术未配置长期任务;");
                    patMedOperationItemMapper.updatePatMedOperationItem(patMedOperationItem);
                } else {
                    for (ServiceTaskoper serviceTaskoper1 : serviceTaskopers) {
                        writeInSubTaskForOp(serviceTaskoper1.getTaskId(), true, opItem, config);
                    }
                }

            } catch (Exception e) {
                e.printStackTrace();
                log.error("人员手术处理出异常了：{}", e.getMessage());
                opItem.setOpercheckFlag("2");
                opItem.setLongTaskReason("人员手术处理异常");
                patMedOperationItemMapper.updatePatMedOperationItem(opItem);
            }
        }
    }

    private void addIcd10SubTask(String config) {
        PatMedInhosp pmjb = new PatMedInhosp();
        //获取需要出院疾病随访，未处理的数据
        pmjb.setDiagcheckFlag("0");
        pmjb.setInhospstate("1");
        pmjb.setFuflag("1");
        List<PatMedInhosp> patMedInhospJBs = patMedInhospMapper.selectPatMedInhospList(pmjb);
        log.info("dealOutHospInfo需要处理的出院疾病患者信息：{}", CollectionUtils.isNotEmpty(patMedInhospJBs) ? patMedInhospJBs.size() : null);
        for (PatMedInhosp patMedInhosp1 : patMedInhospJBs) {
            String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
            patMedInhosp1.setTagname(tagname);
        }

        for (PatMedInhosp pmiJB : patMedInhospJBs) {
            //获取患者信息
            PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(pmiJB.getPatid());
            if (Objects.isNull(patArchive)) {
                pmiJB.setDiagcheckFlag("2");
                pmiJB.setLongTaskReason("患者基本信息为空");
                patMedInhospMapper.updatePatMedInhosp(pmiJB);
                continue;
            }
            try {
                String errorIcd = null;
                if (StringUtils.isEmpty(pmiJB.getLeaveicd10code())) {
                    continue;
                }
                // 根据患者的疾病，获取该疾病的长期任务
                ServiceTaskdiag serviceTaskdiag = new ServiceTaskdiag();
                serviceTaskdiag.setLongtask(1L);
                serviceTaskdiag.setServiceType("2");
                if (active.equals("nhfy")) {
                    //南华附一的icd10code有重复，所以用主诊断名称去查询
                    serviceTaskdiag.setIcd10name(pmiJB.getLeavediagname());
                    if (StringUtils.isEmpty(pmiJB.getLeavediagname())) {
                        errorIcd = "该患者主诊断名称为空;";
                    }
                } else {
                    serviceTaskdiag.setIcd10code(pmiJB.getLeaveicd10code());
                    if (StringUtils.isEmpty(pmiJB.getLeaveicd10code())) {
                        errorIcd = "该患者主诊断ICD10码为空;";
                    }
                }
                serviceTaskdiag.setOrgid(pmiJB.getOrgid());
                List<ServiceTaskdiag> serviceTaskdiags = serviceTaskdiagMapper.selectServiceTaskdiagListByIcdName(serviceTaskdiag);

                //如果部门模板为空（将deptIsNull设置为true）
                if (StringUtils.isNotEmpty(errorIcd)) {
                    PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(pmiJB.getInhospid());
                    pmiJB.setDiagcheckFlag("2");
                    pmiJB.setLongTaskReason(StringUtils.isNotEmpty(patMedInhosp.getLongTaskReason()) ? patMedInhosp.getLongTaskReason() + errorIcd : errorIcd);
                    patMedInhospMapper.updatePatMedInhosp(pmiJB);
                } else if (CollectionUtils.isEmpty(serviceTaskdiags)) {
                    errorIcd = "该患者所患疾病未配置长期任务;";
                    PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(pmiJB.getInhospid());
                    pmiJB.setDiagcheckFlag("2");
                    pmiJB.setLongTaskReason(StringUtils.isNotEmpty(patMedInhosp.getLongTaskReason()) ? patMedInhosp.getLongTaskReason() + errorIcd : errorIcd);
                    patMedInhospMapper.updatePatMedInhosp(pmiJB);
                } else {
                    int flag = 0;
                    for (ServiceTaskdiag serviceTaskdept1 : serviceTaskdiags) {
                        //必须科室或病区能匹配上,才可以用这个疾病创建子任务（主要处理一个疾病在多个病区或科室出现）
                        if (StringUtils.isNotEmpty(serviceTaskdept1.getDeptCode()) && serviceTaskdept1.getDeptCode().equals(pmiJB.getLeaveldeptcode())) {
                            writeInSubTask(serviceTaskdept1.getTaskId(), true, pmiJB, patArchive, 3, config);
                            flag = 1;
                        } else if (StringUtils.isNotEmpty(serviceTaskdept1.getWardCode()) && serviceTaskdept1.getWardCode().equals(pmiJB.getLeavehospitaldistrictcode())) {
                            writeInSubTask(serviceTaskdept1.getTaskId(), true, pmiJB, patArchive, 3, config);
                            flag = 1;
                        }
                    }
                    if (flag == 0) {
                        log.error("该科室或病区对于患者所患疾病未配置长期任务,患者：{}", pmiJB.getInhospid());
                        errorIcd = "该科室或病区对于患者所患疾病未配置长期任务;";
                        PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(pmiJB.getInhospid());
                        pmiJB.setDiagcheckFlag("2");
                        pmiJB.setLongTaskReason(StringUtils.isNotEmpty(patMedInhosp.getLongTaskReason()) ? patMedInhosp.getLongTaskReason() + errorIcd : errorIcd);
                        patMedInhospMapper.updatePatMedInhosp(pmiJB);
                    }

                }

            } catch (Exception e) {
                e.printStackTrace();
                log.error("人员疾病处理出异常了：{}", e.getMessage());
                pmiJB.setDiagcheckFlag("2");
                pmiJB.setLongTaskReason("人员疾病处理异常");
                patMedInhospMapper.updatePatMedInhosp(pmiJB);
            }
        }
    }

    private void addWardSubTask(String config) {
        PatMedInhosp pmbq = new PatMedInhosp();
        //获取需要出院部门随访，未处理的数据
        pmbq.setWardcheckFlag("0");
        pmbq.setInhospstate("1");
        pmbq.setFuflag("1");
        List<PatMedInhosp> patMedInhospBQs = patMedInhospMapper.selectPatMedInhospList(pmbq);
        log.info("dealOutHospInfo需要处理的出院病区患者信息：{}", CollectionUtils.isNotEmpty(patMedInhospBQs) ? patMedInhospBQs.size() : null);
        for (PatMedInhosp patMedInhosp1 : patMedInhospBQs) {
            String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
            patMedInhosp1.setTagname(tagname);
        }

        //病区数据处理
        for (PatMedInhosp pmiBQ1 : patMedInhospBQs) {
            if ("1".equals(pmiBQ1.getLeavehospitaldistrictcode()) && pmiBQ1.getDiagcheckFlag().equals("1")) {
                pmiBQ1.setWardcheckFlag("2");
                pmiBQ1.setLongTaskReason("根据交叉生成随访任务规则，病区任务可以不用生成");
                patMedInhospMapper.updatePatMedInhosp(pmiBQ1);
                continue;
            }

            //获取患者信息
            PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(pmiBQ1.getPatid());
            if (Objects.isNull(patArchive)) {
                pmiBQ1.setWardcheckFlag("2");
                pmiBQ1.setLongTaskReason("患者基本信息为空");
                patMedInhospMapper.updatePatMedInhosp(pmiBQ1);
                continue;
            }
            try {
                String errorreason = null;
                List<ServiceTaskdept> serviceTaskdeptList = null;
                if (!StringUtils.isEmpty(pmiBQ1.getLeavehospitaldistrictcode())) {
                    ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
                    serviceTaskdept.setLongtask(1L);
                    serviceTaskdept.setDeptCode(pmiBQ1.getLeavehospitaldistrictcode());
                    serviceTaskdept.setDeptType("2");
                    serviceTaskdept.setServiceType("2");
                    serviceTaskdept.setOrgid(pmiBQ1.getOrgid());
                    serviceTaskdeptList = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);
                    if (CollectionUtils.isEmpty(serviceTaskdeptList)) {
                        errorreason = "该患者所在病区未配置长期任务;";
                    }
                } else {
                    errorreason = "离院病区为空;";
                }
                //如果部门模板为空（将deptIsNull设置为true）
                if (StringUtils.isNotEmpty(errorreason)) {
                    PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(pmiBQ1.getInhospid());
                    pmiBQ1.setWardcheckFlag("2");
                    pmiBQ1.setLongTaskReason(StringUtils.isNotEmpty(patMedInhosp.getLongTaskReason()) ? patMedInhosp.getLongTaskReason() + errorreason : errorreason);
                    patMedInhospMapper.updatePatMedInhosp(pmiBQ1);
                } else {
                    for (ServiceTaskdept serviceTaskdept1 : serviceTaskdeptList) {
                        writeInSubTask(serviceTaskdept1.getTaskId(), true, pmiBQ1, patArchive, 2, config);
                    }
                }

            } catch (Exception e) {
                e.printStackTrace();
                log.error("人员病区处理出异常了：{}", e.getMessage());
                pmiBQ1.setWardcheckFlag("2");
                pmiBQ1.setLongTaskReason("人员病区处理异常");
                patMedInhospMapper.updatePatMedInhosp(pmiBQ1);
            }
        }
    }

    private void addDeptSubTask(String config) {
        //获取需要出院部门随访，未处理的数据
        PatMedInhosp pmks = new PatMedInhosp();
        pmks.setDeptcheckFlag("0");
        pmks.setInhospstate("1");
        pmks.setFuflag("1");
        List<PatMedInhosp> patMedInhosps = patMedInhospMapper.selectPatMedInhospList(pmks);
        log.info("dealOutHospInfo需要处理的出院部门患者信息：{}", CollectionUtils.isNotEmpty(patMedInhosps) ? patMedInhosps.size() : null);
        for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
            String tagname = patMedInhospMapper.getTagnameBypatid(patMedInhosp1.getPatid());
            patMedInhosp1.setTagname(tagname);
        }

        //科室
        for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
            if ("1".equals(patMedInhosp1.getLeavehospitaldistrictcode()) && patMedInhosp1.getDiagcheckFlag().equals("1")) {
                patMedInhosp1.setDeptcheckFlag("2");
                patMedInhosp1.setLongTaskReason("根据交叉生成随访任务规则，部门任务可以不用生成");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                continue;
            }
            //获取患者信息
            PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedInhosp1.getPatid());
            if (Objects.isNull(patArchive)) {
                patMedInhosp1.setDeptcheckFlag("2");
                patMedInhosp1.setLongTaskReason("患者基本信息为空");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                continue;
            }
            try {
                //根据患者所在科室，获取该科室的长期任务
                ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
                serviceTaskdept.setLongtask(1L);
                serviceTaskdept.setDeptCode(patMedInhosp1.getLeaveldeptcode());
                serviceTaskdept.setDeptType("1");
                serviceTaskdept.setServiceType("2");
                serviceTaskdept.setOrgid(patMedInhosp1.getOrgid());
                List<ServiceTaskdept> serviceTaskdepts = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);
                //如果部门模板为空（将deptIsNull设置为true）
                if (CollectionUtils.isEmpty(serviceTaskdepts) || serviceTaskdepts.size() == 0) {
                    PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                    patMedInhosp1.setDeptcheckFlag("2");
                    patMedInhosp1.setLongTaskReason(patMedInhosp.getLongTaskReason() + "该患者所在科室未配置离院长期任务;");
                    patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                } else {
                    for (ServiceTaskdept serviceTaskdept1 : serviceTaskdepts) {
                        writeInSubTask(serviceTaskdept1.getTaskId(), true, patMedInhosp1, patArchive, 1, config);
                    }
                }

            } catch (Exception e) {
                e.printStackTrace();
                log.error("人员科室处理出异常了：{}", e.getMessage());
                patMedInhosp1.setDeptcheckFlag("2");
                patMedInhosp1.setLongTaskReason("人员科室处理异常");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
            }
        }
    }
@@ -1477,7 +1047,7 @@
        if (StringUtils.isNotEmpty(remark)) {
            updateObj.setRemark(remark + " (type=" + type + ")");
        }
        patMedInhospMapper.updatePatMedInhosp(updateObj);
        inhospVisitFacade.updatePatMedInhosp(updateObj);
    }

    /**
@@ -1485,22 +1055,14 @@
     * 根据患者离院科室或病区查询service_task_rule，获取deptRule、wradRule、diagRule
     * 根据规则值决定调用哪个方法生成随访任务
     */
    private void addSubTaskByRule(String config) {
        // 获取所有需要处理的出院患者（科室维度未处理）
        PatMedInhosp pmks = new PatMedInhosp();
        pmks.setDeptcheckFlag("0");
        pmks.setInhospstate("1");
        pmks.setFuflag("1");
        List<PatMedInhosp> patMedInhosps = patMedInhospMapper.selectPatMedInhospList(pmks);
        log.info("【基于规则】需要处理的出院患者信息：{}", CollectionUtils.isNotEmpty(patMedInhosps) ? patMedInhosps.size() : null);

    private void addSubTaskByRule(String config, List<PatMedInhosp> patMedInhosps) {
        for (PatMedInhosp patMedInhosp1 : patMedInhosps) {
            // 获取患者基本信息
            PatArchive patArchive = patArchiveMapper.selectPatArchiveByPatid(patMedInhosp1.getPatid());
            if (Objects.isNull(patArchive)) {
                patMedInhosp1.setDeptcheckFlag("2");
                patMedInhosp1.setLongTaskReason("患者基本信息为空");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
                continue;
            }

@@ -1646,7 +1208,7 @@
                log.error("【基于规则】患者{}处理异常：{}", patMedInhosp1.getInhospid(), e.getMessage());
                patMedInhosp1.setDeptcheckFlag("2");
                patMedInhosp1.setLongTaskReason("基于规则处理异常");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
            }
        }
    }
@@ -1669,12 +1231,12 @@
            List<ServiceTaskdept> serviceTaskdepts = serviceTaskdeptMapper.selectServiceTaskdeptList(serviceTaskdept);

            if (CollectionUtils.isEmpty(serviceTaskdepts)) {
                PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                PatMedInhosp patMedInhosp = inhospVisitFacade.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                patMedInhosp1.setDeptcheckFlag("2");
                patMedInhosp1.setWardcheckFlag(patMedInhosp.getWardcheckFlag());
                patMedInhosp1.setDiagcheckFlag(patMedInhosp.getDiagcheckFlag());
                patMedInhosp1.setLongTaskReason(patMedInhosp.getLongTaskReason() + "该患者所在科室未配置离院长期任务;");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
            } else {
                for (ServiceTaskdept serviceTaskdept1 : serviceTaskdepts) {
                    writeInSubTask(serviceTaskdept1.getTaskId(), true, patMedInhosp1, patArchive, 1, config);
@@ -1686,7 +1248,7 @@
            log.error("【科室任务】患者{}处理异常：{}", patMedInhosp1.getInhospid(), e.getMessage());
            patMedInhosp1.setDeptcheckFlag("2");
            patMedInhosp1.setLongTaskReason("科室任务处理异常");
            patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
            inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
        }
        return generatedCount;
    }
@@ -1717,12 +1279,12 @@
            }

            if (StringUtils.isNotEmpty(errorreason)) {
                PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                PatMedInhosp patMedInhosp = inhospVisitFacade.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                patMedInhosp1.setWardcheckFlag("2");
                patMedInhosp1.setDeptcheckFlag(patMedInhosp.getDeptcheckFlag());
                patMedInhosp1.setDiagcheckFlag(patMedInhosp.getDiagcheckFlag());
                patMedInhosp1.setLongTaskReason(StringUtils.isNotEmpty(patMedInhosp.getLongTaskReason()) ? patMedInhosp.getLongTaskReason() + errorreason : errorreason);
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
            } else {
                for (ServiceTaskdept serviceTaskdept1 : serviceTaskdeptList) {
                    writeInSubTask(serviceTaskdept1.getTaskId(), true, patMedInhosp1, patArchive, 2, config);
@@ -1734,7 +1296,7 @@
            log.error("【病区任务】患者{}处理异常：{}", patMedInhosp1.getInhospid(), e.getMessage());
            patMedInhosp1.setWardcheckFlag("2");
            patMedInhosp1.setLongTaskReason("病区任务处理异常");
            patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
            inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
        }
        return generatedCount;
    }
@@ -1753,14 +1315,14 @@

            ServiceTaskdiag serviceTaskdiag = new ServiceTaskdiag();
            serviceTaskdiag.setLongtask(1L);
            serviceTaskdiag.setServiceType("2");
//            serviceTaskdiag.setServiceType("2");
            if (active.equals("nhfy")) {
                serviceTaskdiag.setIcd10name(patMedInhosp1.getLeavediagname());
                if (StringUtils.isEmpty(patMedInhosp1.getLeavediagname())) {
                    PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                    PatMedInhosp patMedInhosp = inhospVisitFacade.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                    patMedInhosp1.setDiagcheckFlag("2");
                    patMedInhosp1.setLongTaskReason("该患者主诊断名称为空;");
                    patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
                    inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
                    return 0;
                }
            } else {
@@ -1770,10 +1332,10 @@
            List<ServiceTaskdiag> serviceTaskdiags = serviceTaskdiagMapper.selectServiceTaskdiagListByIcdName(serviceTaskdiag);

            if (CollectionUtils.isEmpty(serviceTaskdiags)) {
                PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                PatMedInhosp patMedInhosp = inhospVisitFacade.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                patMedInhosp.setDiagcheckFlag("2");
                patMedInhosp.setLongTaskReason("该患者所患疾病未配置长期任务;");
                patMedInhospMapper.updatePatMedInhosp(patMedInhosp);
                inhospVisitFacade.updatePatMedInhosp(patMedInhosp);
            } else {
                int flag = 0;
                for (ServiceTaskdiag serviceTaskdiag1 : serviceTaskdiags) {
@@ -1789,10 +1351,10 @@
                }
                if (flag == 0) {
                    log.error("该科室或病区对于患者所患疾病未配置长期任务,患者：{}", patMedInhosp1.getInhospid());
                    PatMedInhosp patMedInhosp = patMedInhospMapper.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                    PatMedInhosp patMedInhosp = inhospVisitFacade.selectPatMedInhospByInhospid(patMedInhosp1.getInhospid());
                    patMedInhosp.setDiagcheckFlag("2");
                    patMedInhosp.setLongTaskReason("该科室或病区对于患者所患疾病未配置长期任务;");
                    patMedInhospMapper.updatePatMedInhosp(patMedInhosp);
                    inhospVisitFacade.updatePatMedInhosp(patMedInhosp);
                }
            }
        } catch (Exception e) {
@@ -1800,10 +1362,9 @@
            log.error("【疾病任务】患者{}处理异常：{}", patMedInhosp1.getInhospid(), e.getMessage());
            patMedInhosp1.setDiagcheckFlag("2");
            patMedInhosp1.setLongTaskReason("疾病任务处理异常");
            patMedInhospMapper.updatePatMedInhosp(patMedInhosp1);
            inhospVisitFacade.updatePatMedInhosp(patMedInhosp1);
        }
        return generatedCount;
    }


}