smartor.git - Gitblit

			@@ -42,6 +42,7 @@
			import java.time.format.DateTimeFormatter;
			import java.time.temporal.ChronoUnit;
			import java.util.*;
			import java.util.concurrent.TimeUnit;
			import java.util.regex.Pattern;
			import java.util.stream.Collectors;

			@@ -122,7 +123,9 @@
			import com.ruoyi.task.domain.ServiceTaskVO;
			import com.ruoyi.task.domain.VO.TransferDeptVO;
			import com.ruoyi.system.service.ISysConfigService;
			import com.ruoyi.system.service.ISysDeptService;
			import com.ruoyi.system.mapper.ext.SysDept2Mapper;
			import com.ruoyi.task.api.contract.OperationSubtaskWriter;

			/**
			* 单一任务（随访）Service业务层处理
			@@ -133,6 +136,15 @@
			@Slf4j
			@Service
			public class ServiceSubtaskServiceImpl implements IServiceSubtaskService {

			/**
			* 随访子任务组装器（原 smartor 侧 IPatMedInhospService#boxedServiceSubtask 在本模块的落地实现）。
			* <p>
			* 二次随访要用「下一任务配置 + 出院记录 + 患者档案」组装新的 service_subtask，
			* 这段口径与长期任务生成完全一致，因此直接复用本模块已有的组装器，不再复制一份。
			*/
			@Autowired
			private OperationSubtaskWriter operationSubtaskWriter;

			/**
			* 满意度模块对外门面（常驻 Bean）。
			@@ -218,6 +230,9 @@
			private TaskArchivePort taskArchivePort;

			@Autowired
			private ISysDeptService sysDeptService;

			@Autowired
			private ScheduleSubtaskBuilder scheduleSubtaskBuilder;


			@@ -260,6 +275,10 @@
			private ServiceOutPathMapper serviceOutPathMapper;

			private static final String KEY_SEP = "\u0001";

			/** 二次随访生成锁前缀，防止同一原任务并发生成多条二次随访 */
			private static final String AGAIN_LOCK_KEY_PREFIX = "smartor:again:lock:";
			private static final long AGAIN_LOCK_SECONDS = 30L;

			/**
			* 查询单一任务（随访）
			@@ -485,7 +504,7 @@
			if (StringUtils.isEmpty(serviceSubtask.getCurrentPreachform())) {
			if (StringUtils.isNotEmpty(serviceSubtask.getPreachform())) {
			//默认取第一个
			serviceSubtaskRes.setCurrentPreachform(serviceSubtask.getPreachform().split(",")[0]);
			serviceSubtaskRes.setCurrentPreachform(serviceSubtask.getPreachform().split(",")[0].trim());
			}
			}
			PatMedInhosp inhosp = loadInhospCached(inhospCache, serviceSubtask.getInhospid());
			@@ -691,11 +710,22 @@

			@Override
			public List<ServiceSubtask> patItem2(ServiceSubtaskEntity serviceSubtaskEntity) {
			if (serviceSubtaskEntity.getSendstateView() != null) {
			// 1：待随访（1 被领取、2 待发送、3 已发送、5 发送失败、7、超时）；2：已完成（ 6 已完成）、3：无需随访（4 不执行）
			if (serviceSubtaskEntity.getSendstateView() == 1)
			serviceSubtaskEntity.setSendstates(new ArrayList<>(Arrays.asList(1L, 2L, 3L, 5L, 7L)));
			if (serviceSubtaskEntity.getSendstateView() == 2)
			serviceSubtaskEntity.setSendstates(new ArrayList<>(Arrays.asList(6L)));
			if (serviceSubtaskEntity.getSendstateView() == 3)
			serviceSubtaskEntity.setSendstates(new ArrayList<>(Arrays.asList(4L)));
			}
			List<ServiceSubtask> serviceSubtaskList = new ArrayList<>();
			for (Long sendstate : serviceSubtaskEntity.getSendstates()) {
			serviceSubtaskEntity.setSendstate(sendstate);
			List<ServiceSubtask> serviceSubtasks = serviceSubtaskMapper.selectServiceSubtaskList(serviceSubtaskEntity);
			serviceSubtaskList.addAll(serviceSubtasks);
			if(CollectionUtils.isNotEmpty(serviceSubtaskEntity.getSendstates())){
			for (Long sendstate : serviceSubtaskEntity.getSendstates()) {
			serviceSubtaskEntity.setSendstate(sendstate);
			List<ServiceSubtask> serviceSubtasks = serviceSubtaskMapper.selectServiceSubtaskList(serviceSubtaskEntity);
			serviceSubtaskList.addAll(serviceSubtasks);
			}
			}
			return serviceSubtaskList;
			}
			@@ -765,6 +795,7 @@
			result.putIfAbsent("xsf", 0);
			result.putIfAbsent("dsf", 0);
			result.putIfAbsent("ywc", 0);
			result.putIfAbsent("cs", 0);
			result.putIfAbsent("yc", 0);
			result.putIfAbsent("jg", 0);
			}
			@@ -801,6 +832,7 @@
			result.putIfAbsent("dsf", 0);
			result.putIfAbsent("dfs", 0);
			result.putIfAbsent("yfs", 0);
			result.putIfAbsent("cs", 0);
			result.putIfAbsent("ywc", 0);
			result.putIfAbsent("yc", 0);
			result.putIfAbsent("jg", 0);
			@@ -881,7 +913,7 @@
			serviceOutPath.setSubId(serviceSubtask1.getId());
			List<ServiceOutPath> serviceOutPaths = serviceOutPathMapper.selectServiceOutPathList(serviceOutPath);
			if (CollectionUtils.isNotEmpty(serviceOutPaths))
			format = String.format("%03X", serviceOutPaths.get(0).getId());
			format = ShortCode.encode(serviceOutPaths.get(0).getId());
			else format = getOutPath(serviceSubtask1, rsaPublicKeyExample);
			serviceSubtask = serviceSubtask1;
			} else {
			@@ -933,7 +965,7 @@
			serviceOutPath.setSubId(serviceSubtask.getId());
			iServiceOutPathService.insertServiceOutPath(serviceOutPath);
			//转成16进制
			format = String.format("%03X", serviceOutPath.getId());
			format = ShortCode.encode(serviceOutPath.getId());
			serviceOutPath.setRadix(format);
			serviceOutPath.setUpdateTime(new Date());
			iServiceOutPathService.updateServiceOutPath(serviceOutPath);
			@@ -947,6 +979,7 @@
			* @return 结果
			*/
			@Override
			@Transactional(rollbackFor = Exception.class)
			public String addSubTaskAgain(ServiceSubtask serviceSubtask) {
			ServiceSubtask serviceSubtask1 = selectServiceSubtaskById(serviceSubtask.getId());
			PatMedInhosp patMedInhosp = new PatMedInhosp();
			@@ -956,7 +989,7 @@
			PatArchive patArchive = taskArchivePort.findByPatid(serviceSubtask1.getPatid());
			//景宁新增再次随访不能触发患者再入院
			boolean inhospAgain = true;
			if (serviceSubtask1.getOrgid().equals("47255004333112711A1001")) {
			if ("47255004333112711A1001".equals(serviceSubtask1.getOrgid())) {
			inhospAgain = false;
			}
			if (patMedInhospList.size() > 0 && inhospAgain) {
			@@ -970,13 +1003,17 @@
			serviceSubtask1.setRemark(StringUtils.isNotEmpty(serviceSubtask.getRemark()) ? serviceSubtask.getRemark() + ";无需再次随访，任务被标记不在执行" : "无需再次随访，任务被标记不在执行");
			serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
			return "无需再次随访，任务被标记不在执行";
			} else if (StringUtils.isNotEmpty(patArchive.getNotrequiredFlag()) && patArchive.getNotrequiredFlag().equals("1")) {
			} else if (patArchive != null && StringUtils.isNotEmpty(patArchive.getNotrequiredFlag()) && patArchive.getNotrequiredFlag().equals("1")) {
			serviceSubtask1.setIsVisitAgain(2);
			serviceSubtaskMapper.updateServiceSubtask(serviceSubtask1);
			serviceSubtask1.setRemark(StringUtils.isNotEmpty(serviceSubtask.getRemark()) ? serviceSubtask.getRemark() + ";无需再次随访，患者被标记不需要被服务" : "无需再次随访，患者被标记不需要被服务");
			return "无需再次随访，患者被标记不需要被服务";
			} else if (ObjectUtils.isNotEmpty(serviceSubtask1.getIsVisitAgain()) && serviceSubtask1.getIsVisitAgain() == 2) {
			return "无需再次随访，该任务已经再次随访过了";
			}
			//丽水中医院根据下次任务ID生成再次随访
			if ("47231022633110211A2101".equals(serviceSubtask1.getOrgid())) {
			return addSubTaskAgainNextTaskId(serviceSubtask1, serviceSubtask);
			}
			//新增再次随访任务
			ServiceSubtask serviceSubtask2 = DtoConversionUtils.sourceToTarget(serviceSubtask, ServiceSubtask.class);
			@@ -1004,6 +1041,495 @@
			return "再次随访任务创建成功";
			}
			return "再次随访任务创建失败，再请次重试";
			}

			public String addSubTaskAgainNextTaskId(ServiceSubtask serviceSubtask, ServiceSubtask request) {
			if (ObjectUtils.isEmpty(serviceSubtask.getTaskid())) {
			log.error("再次随访任务创建失败，缺少TaskId, 再请次重试");
			return "再次随访任务创建失败，缺少TaskId, 再请次重试";
			}
			// 同一原任务串行生成，防止并发重复插入
			String lockToken = tryLockAgainTask(serviceSubtask.getId());
			if (lockToken == null) {
			return "再次随访任务正在创建中，请勿重复提交";
			}
			try {
			ServiceTask serviceTask = serviceTaskService.selectServiceTaskByTaskid(serviceSubtask.getTaskid());
			if (ObjectUtils.isEmpty(serviceTask)) {
			log.error("再次随访任务创建失败，找不到对应任务 taskid = {}, 再请次重试", serviceSubtask.getTaskid());
			return "再次随访任务创建失败，找不到对应任务 taskid = " + serviceSubtask.getTaskid() + ", 再请次重试";
			}
			// nexttaskflag=0 表示任务链终止，不允许再生成
			// if ("0".equals(serviceTask.getNexttaskflag())) {
			// log.info("无需再次随访，任务已标记无后续随访, taskid = {}", serviceSubtask.getTaskid());
			// return "无需再次随访，该任务无后续随访安排";
			// }
			// 幂等校验：同一原任务只允许生成一条二次随访
			ServiceSubtaskEntity againQuery = new ServiceSubtaskEntity();
			againQuery.setUpid(serviceSubtask.getId().intValue());
			if (CollectionUtils.isNotEmpty(serviceSubtaskMapper.selectServiceSubtaskList(againQuery))) {
			return "无需再次随访，该任务已经再次随访过了";
			}
			// 查询出院记录
			PatMedInhosp patMedInhospVo = new PatMedInhosp();
			patMedInhospVo.setOrgid(serviceSubtask.getOrgid());
			patMedInhospVo.setInhospid(serviceSubtask.getInhospid());
			patMedInhospVo.setCry(1);
			List<PatMedInhosp> patMedInhospList = inhospVisitFacade.selectPatMedInhospList(patMedInhospVo);
			PatMedInhosp patMedInhosp = new PatMedInhosp();
			if (CollectionUtils.isNotEmpty(patMedInhospList)) {
			patMedInhosp = patMedInhospList.get(0);
			} else {
			log.error("再次随访任务创建失败，任务缺少对应的出院记录, taskid = {}, 再请次重试", serviceSubtask.getTaskid());
			return "再次随访任务创建失败，任务缺少对应的出院记录, taskid = " + serviceSubtask.getTaskid() + ", 再请次重试";
			}
			// 未配置 nexttaskid 时复用当前任务配置，防止历史任务直接失败
			Long nexttaskid = serviceTask.getNexttaskid();
			if (ObjectUtils.isEmpty(nexttaskid) \|\| Long.valueOf(0L).equals(nexttaskid)) {
			nexttaskid = serviceTask.getTaskid();
			log.warn("再次随访任务未配置 nexttaskid，按当前任务配置生成, taskid = {}", nexttaskid);
			}
			ServiceTask nextServiceTask = serviceTaskService.selectServiceTaskByTaskid(nexttaskid);
			if (ObjectUtils.isEmpty(nextServiceTask)) {
			log.error("再次随访任务创建失败，找不到对应任务 nexttaskid = {}, 再请次重试", nexttaskid);
			return "再次随访任务创建失败，找不到对应任务 nexttaskid = " + nexttaskid + ", 再请次重试";
			}
			PatArchive patArchive = taskArchivePort.findByPatid(serviceSubtask.getPatid());
			if (ObjectUtils.isEmpty(patArchive)) {
			log.error("再次随访任务创建失败，未找到患者档案 patid = {}, subTaskId = {}", serviceSubtask.getPatid(), serviceSubtask.getId());
			return "再次随访任务创建失败，未找到患者档案, subTaskId = " + serviceSubtask.getId() + ", 再请次重试";
			}
			String config = sysConfigService.selectConfigByKey("visit.early.day");
			Integer type = 1;
			String resource = resolveAgainResource(request);
			if (StringUtils.isEmpty(resource)) {
			String requestResource = request == null ? null : request.getResource();
			log.error("再次随访任务创建失败，再次随访方式不合法, resource = {}, subTaskId = {}", requestResource, serviceSubtask.getId());
			return "再次随访任务创建失败，再次随访方式不合法, resource = " + requestResource + ", 再请次重试";
			}
			String visitDeptCode;
			String visitDeptName;
			if ("1".equals(resource)) {
			// 本科室随访：请求科室优先，未传时使用原任务出院科室；不依赖原任务 visitType
			String requestDeptCode = firstNonBlank(request == null ? null : request.getVisitDeptCode());
			String requestDeptName = firstNonBlank(request == null ? null : request.getVisitDeptName());
			if (StringUtils.isNotEmpty(requestDeptCode)) {
			visitDeptCode = requestDeptCode;
			visitDeptName = requestDeptName;
			} else {
			// 出院科室：service_subtask 里对应的是 leaveldeptcode（deptcode 已改为在院科室）
			visitDeptCode = serviceSubtask.getLeaveldeptcode();
			visitDeptName = serviceSubtask.getLeaveldeptname();
			}
			if (StringUtils.isEmpty(visitDeptCode)) {
			log.error("再次随访任务创建失败，本科室随访未找到随访科室, subTaskId = {}", serviceSubtask.getId());
			return "再次随访任务创建失败，本科室随访未找到随访科室, subTaskId = " + serviceSubtask.getId() + ", 再请次重试";
			}
			SysDept ownDept = selectDeptByCode(serviceSubtask.getOrgid(), visitDeptCode);
			if (ObjectUtils.isNotEmpty(ownDept)) {
			visitDeptCode = ownDept.getDeptCode();
			visitDeptName = ownDept.getDeptName();
			} else if (StringUtils.isNotEmpty(requestDeptCode) \|\| StringUtils.isEmpty(visitDeptName)) {
			log.error("再次随访任务创建失败，本科室随访科室不存在, deptCode = {}, subTaskId = {}", visitDeptCode, serviceSubtask.getId());
			return "再次随访任务创建失败，本科室随访科室不存在, deptCode = " + visitDeptCode + ", 再请次重试";
			}
			} else {
			// 随访中心科室随访
			String centerDept = sysConfigService.selectConfigByKey("sys.smartor.center.dept", serviceSubtask.getOrgid());
			if (ObjectUtils.isEmpty(centerDept)) {
			log.error("再次随访任务创建失败，未配置随访中心科室参数 sys.smartor.center.dept ,subTaskId = {}, 再请次重试", serviceSubtask.getId());
			return "再次随访任务创建失败，未配置随访中心科室参数 sys.smartor.center.dept ,subTaskId = " + serviceSubtask.getId() + ", 再请次重试";
			}
			SysDept sysDeptVo = new SysDept();
			sysDeptVo.setDeptType("1");
			sysDeptVo.setOrgid(serviceSubtask.getOrgid());
			sysDeptVo.setDeptCode(centerDept);
			List<SysDept> sysDepts = sysDeptService.selectDeptList(sysDeptVo);
			SysDept sysDept = new SysDept();
			if (CollectionUtils.isNotEmpty(sysDepts)) {
			sysDept = sysDepts.get(0);
			} else {
			log.error("再次随访任务创建失败，未找到参数 sys.smartor.center.dept 配置的随访中心科室 deptCode = {}, 再请次重试", centerDept);
			return "再次随访任务创建失败，未找到参数 sys.smartor.center.dept 配置的随访中心科室 deptCode = " + centerDept + ", 再请次重试";
			}
			visitDeptCode = sysDept.getDeptCode();
			visitDeptName = sysDept.getDeptName();
			}

			// 按下一任务生成二次随访子任务（表单、发送方式取自下一任务）；
			// 组装逻辑已在本模块的 OperationSubtaskWriter 里（原 IPatMedInhospService#boxedServiceSubtask），这里直接复用
			ServiceSubtask serviceSubtaskAgain = operationSubtaskWriter.boxedServiceSubtask(nextServiceTask,
			patMedInhosp, patArchive, config, type);
			if (ObjectUtils.isEmpty(serviceSubtaskAgain) \|\| ObjectUtils.isEmpty(serviceSubtaskAgain.getTaskid())) {
			log.error("再次随访任务创建失败，下一任务生成子任务为空, subTaskId = {}, nextTaskId = {}", serviceSubtask.getId(), nexttaskid);
			return "再次随访任务创建失败，患者出院记录不完整或下一任务配置异常, 再请次重试";
			}
			Date now = new Date();
			applyAgainVisitTime(serviceSubtaskAgain, serviceSubtask, nextServiceTask, config, now);
			// 医生处理意见取自本次请求，按下一任务重建子任务时需显式带入，否则不会落库
			if (request != null) {
			serviceSubtaskAgain.setDoctorOpinion(request.getDoctorOpinion());
			serviceSubtaskAgain.setRemark(request.getRemark());
			serviceSubtaskAgain.setDrcode(request.getDrcode());
			serviceSubtaskAgain.setDrname(request.getDrname());
			serviceSubtaskAgain.setNurseId(request.getNurseId());
			serviceSubtaskAgain.setNurseName(request.getNurseName());
			serviceSubtaskAgain.setManagementDoctor(request.getManagementDoctor());
			serviceSubtaskAgain.setManagementDoctorCode(request.getManagementDoctorCode());
			}
			serviceSubtaskAgain.setId(null);
			serviceSubtaskAgain.setUpid(serviceSubtask.getId().intValue());
			serviceSubtaskAgain.setVisitCount(ObjectUtils.isNotEmpty(serviceSubtask.getVisitCount())
			? serviceSubtask.getVisitCount() + 1 : 2);
			serviceSubtaskAgain.setSendstate(2L);
			serviceSubtaskAgain.setIsVisitAgain(1);
			serviceSubtaskAgain.setCreateTime(now);
			serviceSubtaskAgain.setUpdateTime(now);
			// 新任务的随访方式记录本次选择的再次随访方式；resource 本身不落库
			serviceSubtaskAgain.setVisitType(resource);
			serviceSubtaskAgain.setVisitDeptCode(visitDeptCode);
			serviceSubtaskAgain.setVisitDeptName(visitDeptName);
			int i = serviceSubtaskMapper.insertServiceSubtask(serviceSubtaskAgain);
			if (i != 1) {
			return "再次随访任务创建失败，再请次重试";
			}
			// 初始化发送方式明细，补偿（compensateTask）和超时判断依赖该表
			addServiceSubtaskPreachform(serviceSubtaskAgain, null);
			// 条件更新原任务：0 行说明已被其他请求生成，抛异常回滚本次插入的重复数据
			int updated = serviceSubtaskMapper.updateIsVisitAgainById(serviceSubtask.getId(), 2);
			if (updated != 1) {
			throw new BaseException("无需再次随访，该任务已经再次随访过了");
			}
			return "再次随访任务创建成功";
			} finally {
			unlockAgainTask(serviceSubtask.getId(), lockToken);
			}
			}

			/**
			* 解析再次随访方式：仅取请求参数 resource，不使用原任务 visitType；未传时默认随访中心。
			*
			* @return 1-本科室随访；2-随访中心随访；null-非法值
			*/
			private String resolveAgainResource(ServiceSubtask request) {
			String resource = request == null ? null : request.getResource();
			if (StringUtils.isEmpty(resource) \|\| StringUtils.isEmpty(resource.trim())) {
			return "2";
			}
			resource = resource.trim();
			return ("1".equals(resource) \|\| "2".equals(resource)) ? resource : null;
			}

			private String firstNonBlank(String... values) {
			if (values == null) {
			return null;
			}
			for (String value : values) {
			if (StringUtils.isNotEmpty(value) && StringUtils.isNotEmpty(value.trim())) {
			return value.trim();
			}
			}
			return null;
			}

			/**
			* 按 orgid + deptCode 查询启用科室，查不到返回 null。
			*/
			private SysDept selectDeptByCode(String orgid, String deptCode) {
			if (StringUtils.isEmpty(orgid) \|\| StringUtils.isEmpty(deptCode)) {
			return null;
			}
			SysDept query = new SysDept();
			query.setDeptType("1");
			query.setOrgid(orgid);
			query.setDeptCode(deptCode);
			List<SysDept> deptList = sysDeptService.selectDeptList(query);
			return CollectionUtils.isEmpty(deptList) ? null : deptList.get(0);
			}

			/**
			* 二次随访时间：首次随访完成时间（未完成取当前时间）+ 下一任务发送天数，过去时间兜底为当前时间。
			* 通知类任务按 visit.early.day 提前发送。
			*/
			private void applyAgainVisitTime(ServiceSubtask target, ServiceSubtask origin, ServiceTask nextTask,
			String earlyDayConfig, Date now) {
			if (target == null \|\| origin == null \|\| nextTask == null \|\| now == null) {
			return;
			}
			Date baseTime = ObjectUtils.isNotEmpty(origin.getFinishtime()) ? origin.getFinishtime() : now;
			int intervalDays = ObjectUtils.isNotEmpty(nextTask.getSendDay()) ? nextTask.getSendDay().intValue() : 0;
			Date dueTime = addDays(baseTime, intervalDays);
			if (dueTime.before(now)) {
			dueTime = now;
			}
			if(ObjectUtils.isNotEmpty(origin.getVisitTime())){
			dueTime = ObjectUtils.isNotEmpty(origin.getVisitTime()) ? origin.getVisitTime() : now;
			}

			target.setLongSendTime(dueTime);
			Date visitTime = dueTime;
			if ("3".equals(nextTask.getType())) {
			visitTime = addDays(dueTime, -parseIntConfig(earlyDayConfig));
			if (visitTime.before(now)) {
			visitTime = now;
			}
			}
			target.setVisitTime(visitTime);
			}

			private int parseIntConfig(String value) {
			if (StringUtils.isEmpty(value)) {
			return 0;
			}
			try {
			return Integer.parseInt(value.trim());
			} catch (NumberFormatException e) {
			log.warn("配置值不是合法整数，按0处理, value={}", value);
			return 0;
			}
			}

			/**
			* 日期加减天数（days 可为负）。
			* <p>
			* 说明：本模块其它地方用的是 {@code DateUtils.addDays}，但 ruoyi-common 的 DateUtils 并未提供该方法，
			* 这里是二次随访时间计算自带的私有实现，避免依赖不存在的工具方法。
			*/
			private Date addDays(Date date, int days) {
			if (date == null) {
			return null;
			}
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(date);
			calendar.add(Calendar.DAY_OF_MONTH, days);
			return calendar.getTime();
			}

			/**
			* 首次随访任务超时后，按下一任务自动生成再次随访任务。
			* <p>
			* 定时任务入口 {@code RyTask#dealSubtaskDeadline} 使用。与手动入口一致的部分：
			* 表单/发送方式取下一任务、链路 upid + visit_count、发送方式明细初始化；
			* 差异：超时再次随访固定走随访中心科室（随访中心未配置时回退原任务科室），原任务置为发送失败（sendstate=5）。
			* <p>
			* 幂等：同一原任务只允许生成一条再次随访（Redis 锁 + upid 校验 + 原任务条件更新），
			* 多节点/多线程同时扫描时，后到的事务会在条件更新处拿到 0 行并回滚本次插入。
			*
			* @param serviceSubtask 已超时的首次随访子任务
			* @return 结果描述
			*/
			@Override
			@Transactional(rollbackFor = Exception.class)
			public String addSubTaskAgainByDeadline(ServiceSubtask serviceSubtask) {
			if (ObjectUtils.isEmpty(serviceSubtask) \|\| ObjectUtils.isEmpty(serviceSubtask.getId())) {
			return "再次随访任务创建失败，原任务不存在";
			}
			String lockToken = tryLockAgainTask(serviceSubtask.getId());
			if (lockToken == null) {
			return "再次随访任务正在创建中，请勿重复提交";
			}
			try {
			// 幂等校验：同一原任务只允许生成一条再次随访
			ServiceSubtaskEntity againQuery = new ServiceSubtaskEntity();
			againQuery.setUpid(serviceSubtask.getId().intValue());
			if (CollectionUtils.isNotEmpty(serviceSubtaskMapper.selectServiceSubtaskList(againQuery))) {
			return "无需再次随访，该任务已经再次随访过了";
			}
			// 原任务已被标记为不再随访（手动入口写过 is_visit_again=2）
			if (ObjectUtils.isNotEmpty(serviceSubtask.getIsVisitAgain()) && serviceSubtask.getIsVisitAgain() == 2) {
			return "无需再次随访，该任务已经再次随访过了";
			}
			ServiceTask serviceTask = serviceTaskService.selectServiceTaskByTaskid(serviceSubtask.getTaskid());
			if (ObjectUtils.isEmpty(serviceTask)) {
			return "再次随访任务创建失败，找不到对应任务 taskid = " + serviceSubtask.getTaskid();
			}
			if ("0".equals(serviceTask.getNexttaskflag())) {
			return "无需再次随访，该任务无后续随访安排";
			}
			if (ObjectUtils.isEmpty(serviceTask.getNexttaskid())) {
			return "再次随访任务创建失败，任务缺少 nexttaskid, taskid = " + serviceSubtask.getTaskid();
			}
			ServiceTask nextServiceTask = serviceTaskService.selectServiceTaskByTaskid(serviceTask.getNexttaskid());
			if (ObjectUtils.isEmpty(nextServiceTask)) {
			return "再次随访任务创建失败，找不到对应任务 nexttaskid = " + serviceTask.getNexttaskid();
			}
			PatMedInhosp patMedInhosp = selectOutHospRecord(serviceSubtask);
			if (ObjectUtils.isEmpty(patMedInhosp)) {
			return "再次随访任务创建失败，任务缺少对应的出院记录, taskid = " + serviceSubtask.getTaskid();
			}
			PatArchive patArchive = taskArchivePort.findByPatid(serviceSubtask.getPatid());
			if (ObjectUtils.isEmpty(patArchive)) {
			return "再次随访任务创建失败，未找到患者档案, subTaskId = " + serviceSubtask.getId();
			}
			String config = sysConfigService.selectConfigByKey("visit.early.day");
			String visitDeptCode;
			String visitDeptName;
			// 随访中心科室：未配置（或科室不存在）时回退原任务科室，保持超时入口原有行为
			SysDept centerDept = selectCenterDept(serviceSubtask.getOrgid());
			if (ObjectUtils.isNotEmpty(centerDept)) {
			visitDeptCode = centerDept.getDeptCode();
			visitDeptName = centerDept.getDeptName();
			} else {
			String fallbackDeptCode = firstNonBlank(serviceSubtask.getVisitDeptCode());
			if (StringUtils.isNotEmpty(fallbackDeptCode)) {
			visitDeptCode = fallbackDeptCode;
			visitDeptName = serviceSubtask.getVisitDeptName();
			} else {
			// 出院科室：service_subtask 里对应的是 leaveldeptcode（deptcode 已改为在院科室）
			visitDeptCode = serviceSubtask.getLeaveldeptcode();
			visitDeptName = serviceSubtask.getLeaveldeptname();
			}
			}
			// 组装逻辑复用本模块 OperationSubtaskWriter（原 IPatMedInhospService#boxedServiceSubtask）
			ServiceSubtask serviceSubtaskAgain = operationSubtaskWriter.boxedServiceSubtask(nextServiceTask,
			patMedInhosp, patArchive, config, 1);
			if (ObjectUtils.isEmpty(serviceSubtaskAgain) \|\| ObjectUtils.isEmpty(serviceSubtaskAgain.getTaskid())) {
			return "再次随访任务创建失败，患者出院记录不完整或下一任务配置异常, subTaskId = " + serviceSubtask.getId();
			}
			Date now = new Date();
			serviceSubtaskAgain.setId(null);
			serviceSubtaskAgain.setUpid(serviceSubtask.getId().intValue());
			serviceSubtaskAgain.setVisitCount(ObjectUtils.isNotEmpty(serviceSubtask.getVisitCount())
			? serviceSubtask.getVisitCount() + 1 : 2);
			serviceSubtaskAgain.setSendstate(2L);
			serviceSubtaskAgain.setIsVisitAgain(1);
			serviceSubtaskAgain.setCreateTime(now);
			serviceSubtaskAgain.setUpdateTime(now);
			// 超时再次随访固定为随访中心随访
			serviceSubtaskAgain.setVisitType("2");
			serviceSubtaskAgain.setVisitDeptCode(visitDeptCode);
			serviceSubtaskAgain.setVisitDeptName(visitDeptName);
			if (serviceSubtaskMapper.insertServiceSubtask(serviceSubtaskAgain) != 1) {
			return "再次随访任务创建失败，再请次重试";
			}
			// 初始化发送方式明细，补偿（compensateTask）和超时判断依赖该表
			addServiceSubtaskPreachform(serviceSubtaskAgain, null);
			// 条件更新原任务：0 行说明已被其他请求生成，抛异常回滚本次插入的重复数据
			if (serviceSubtaskMapper.updateIsVisitAgainById(serviceSubtask.getId(), 2) != 1) {
			throw new BaseException("无需再次随访，该任务已经再次随访过了");
			}
			// 原任务超时，置为发送失败
			ServiceSubtask originUpdate = new ServiceSubtask();
			originUpdate.setId(serviceSubtask.getId());
			originUpdate.setSendstate(5L);
			originUpdate.setUpdateTime(now);
			serviceSubtaskMapper.updateServiceSubtask(originUpdate);
			return "再次随访任务创建成功";
			} finally {
			unlockAgainTask(serviceSubtask.getId(), lockToken);
			}
			}

			/**
			* 按 orgid + inhospid 取出院记录（超时再次随访用）。
			*/
			private PatMedInhosp selectOutHospRecord(ServiceSubtask serviceSubtask) {
			PatMedInhosp patMedInhospVo = new PatMedInhosp();
			patMedInhospVo.setOrgid(serviceSubtask.getOrgid());
			patMedInhospVo.setInhospid(serviceSubtask.getInhospid());
			patMedInhospVo.setCry(1);
			List<PatMedInhosp> patMedInhospList = inhospVisitFacade.selectPatMedInhospList(patMedInhospVo);
			if (CollectionUtils.isEmpty(patMedInhospList)) {
			return null;
			}
			return patMedInhospList.get(0);
			}

			/**
			* 取随访中心科室，未配置或科室不存在时返回 null（由调用方回退原任务科室）。
			*/
			private SysDept selectCenterDept(String orgid) {
			String centerDept = sysConfigService.selectConfigByKey("sys.smartor.center.dept", orgid);
			if (StringUtils.isEmpty(centerDept)) {
			return null;
			}
			SysDept sysDeptVo = new SysDept();
			sysDeptVo.setDeptType("1");
			sysDeptVo.setOrgid(orgid);
			sysDeptVo.setDeptCode(centerDept);
			// 定时任务线程没有登录上下文，不能调用带 @DataScope 的 selectDeptList，否则会抛“获取用户信息异常”。
			List<SysDept> sysDepts = sysDeptService.selectSysDeptList(sysDeptVo);
			return CollectionUtils.isEmpty(sysDepts) ? null : sysDepts.get(0);
			}

			/**
			* 获取二次随访生成锁。Redis 异常时降级为数据库幂等校验，不阻断业务。
			*/
			private String tryLockAgainTask(Long subId) {
			String token = UUID.randomUUID().toString();
			try {
			Boolean locked = redisCache.setCacheObjectIfAbsent(
			AGAIN_LOCK_KEY_PREFIX + subId, token, AGAIN_LOCK_SECONDS, TimeUnit.SECONDS);
			return Boolean.TRUE.equals(locked) ? token : null;
			} catch (Exception e) {
			log.warn("再次随访获取Redis锁失败，降级使用数据库幂等校验, subId={}", subId, e);
			return token;
			}
			}

			/**
			* 释放二次随访生成锁，仅释放自己持有的锁。
			*/
			private void unlockAgainTask(Long subId, String token) {
			if (token == null) {
			return;
			}
			try {
			String lockKey = AGAIN_LOCK_KEY_PREFIX + subId;
			Object current = redisCache.getCacheObject(lockKey);
			if (token.equals(current)) {
			redisCache.deleteObject(lockKey);
			}
			} catch (Exception e) {
			log.warn("再次随访释放Redis锁失败, subId={}", subId, e);
			}
			}

			/**
			* 按任务的 preachformDesc 初始化发送方式明细（service_subtask_preachform）。
			* <p>
			* 迁移说明：原实现是 smartor 侧 {@code IPatMedInhospService#addServiceSubtaskPreachform}，
			* 读写的两张表都属于本模块，故按模块边界搬到这里，语义保持一致：
			* 先按 subid+preachform 查重（已存在就不新增），sendstate 默认为 "1"（传参可覆盖）。
			*
			* @param serviceSubtask 已落库的子任务
			* @param sendstate 发送状态覆盖值，为空则用 "1"
			* @return 固定返回 0（与原实现一致）
			*/
			private Integer addServiceSubtaskPreachform(ServiceSubtask serviceSubtask, String sendstate) {
			ServiceTask serviceTask = serviceTaskService.selectServiceTaskByTaskid(serviceSubtask.getTaskid());
			if (serviceTask == null) {
			log.error("addServiceSubtaskPreachform taskid={} 查不到任务，跳过preachform子表生成", serviceSubtask.getTaskid());
			return 0;
			}
			String preachformDesc = serviceTask.getPreachformDesc();
			if (StringUtils.isEmpty(preachformDesc)) {
			return 0;
			}
			List<ServiceSubtaskPreachform> preachformList;
			try {
			preachformList = JSON.parseArray(preachformDesc, ServiceSubtaskPreachform.class);
			} catch (Exception e) {
			log.error("preachform转List<ServiceSubtaskPreachform>报错了：{}", e.getMessage());
			return 0;
			}
			if (CollectionUtils.isEmpty(preachformList)) {
			log.error("preachformDesc解析后为空，跳过preachform子表生成，taskid为：{}，preachformDesc为：{}",
			serviceSubtask.getTaskid(), preachformDesc);
			return 0;
			}
			for (ServiceSubtaskPreachform serviceSubtaskPreachform : preachformList) {
			serviceSubtaskPreachform.setTaskid(serviceSubtask.getTaskid());
			serviceSubtaskPreachform.setSubid(serviceSubtask.getId());
			//先查询一下，是否存在，如果已经存在，就不新增了
			if (CollectionUtils.isNotEmpty(taskPreachformPort.selectServiceSubtaskPreachformList(serviceSubtaskPreachform))) {
			continue;
			}
			serviceSubtaskPreachform.setSendstate(StringUtils.isNotEmpty(sendstate) ? sendstate : "1");
			serviceSubtaskPreachform.setOrgid(serviceSubtask.getOrgid());
			taskPreachformPort.insertServiceSubtaskPreachform(serviceSubtaskPreachform);
			}
			return 0;
			}

			/**
			@@ -1059,6 +1585,20 @@
			}

			/**
			* 科室编码去重，保持原顺序，避免 service_task.deptcode 超长和 service_taskdept 重复绑定
			*/
			private String normalizeDeptCodes(String deptCodes) {
			if (StringUtils.isEmpty(deptCodes)) {
			return deptCodes;
			}
			return Arrays.stream(deptCodes.split(","))
			.map(String::trim)
			.filter(code -> StringUtils.isNotEmpty(code))
			.distinct()
			.collect(Collectors.joining(","));
			}

			/**
			* 单一任务
			*
			* @return 结果
			@@ -1070,6 +1610,8 @@
			log.info("任务入参为空，请检查入参");
			throw new BaseException("任务入参为空，请检查入参");
			}
			// 科室编码去重，避免 service_task.deptcode 超长及 service_taskdept 重复绑定
			serviceTaskVO.setDeptcode(normalizeDeptCodes(serviceTaskVO.getDeptcode()));
			ServiceTask serviceTask = DtoConversionUtils.sourceToTarget(serviceTaskVO, ServiceTask.class);
			if (CollectionUtils.isEmpty(serviceTaskVO.getPreachformList())) throw new BaseException("任务的发送方式为空");
			//将preachfromList放到serviceTask中的preachfrom中
			@@ -1304,7 +1846,12 @@
			serviceSubtask.setInhospid(patTaskRelevance.getHospid());
			//新建完成就是待发送状态
			serviceSubtask.setSendstate(2L);
			serviceSubtask.setLeaveldeptcode(StringUtils.isNotEmpty(patTaskRelevance.getDeptcode()) ? patTaskRelevance.getDeptcode() : serviceTaskVO.getDeptcode());
			String subtaskDeptCode = patTaskRelevance.getDeptcode();
			if (StringUtils.isEmpty(subtaskDeptCode) && StringUtils.isNotEmpty(serviceTaskVO.getDeptcode())) {
			// service_subtask.leaveldeptcode 为单值字段，不能写入任务的多科室拼接串，取第一个科室兜底
			subtaskDeptCode = serviceTaskVO.getDeptcode().split(",")[0].trim();
			}
			serviceSubtask.setLeaveldeptcode(subtaskDeptCode);
			serviceSubtask.setLeaveldeptname(StringUtils.isNotEmpty(patTaskRelevance.getDeptName()) ? patTaskRelevance.getDeptName() : serviceTaskVO.getDeptname());
			serviceSubtask.setLeavehospitaldistrictcode(patTaskRelevance.getLeavehospitaldistrictcode());
			serviceSubtask.setLeavehospitaldistrictname(patTaskRelevance.getLeavehospitaldistrictname());
			@@ -1377,6 +1924,8 @@
			ServiceTask serviceTask1 = serviceTaskService.selectServiceTaskByTaskid(serviceTask.getTaskid());
			ServiceSubtaskEntity serviceSubtaskVO = new ServiceSubtaskEntity();
			serviceSubtaskVO.setTaskid(serviceTask1.getTaskid());
			//只删除首次随访未完成的
			serviceSubtaskVO.setVisitCount(1);
			serviceSubtaskVO.setSendstate(2L);
			List<ServiceSubtask> serviceSubtaskList = serviceSubtaskMapper.selectServiceSubtaskList(serviceSubtaskVO);
			serviceSubtaskVO.setSendstate(1L);
			@@ -1442,6 +1991,11 @@
			if (StringUtils.isNotEmpty(serviceTaskVO.getAppltype())) {
			if (serviceTaskVO.getAppltype().equals("1") \|\| serviceTaskVO.getAppltype().equals("2")) {
			if (StringUtils.isNotEmpty(serviceTaskVO.getDeptcode())) {
			// 修改任务时先软删除旧的科室绑定，避免旧科室残留
			ServiceTaskdept oldDept = new ServiceTaskdept();
			oldDept.setTaskId(serviceTask.getTaskid());
			oldDept.setDeptType("1");
			serviceTaskdeptService.deleteServiceTaskdeptByTaskId(oldDept);
			String[] deptcodes = serviceTaskVO.getDeptcode().split(",");
			for (String deptCode : deptcodes) {
			ServiceTaskdept serviceTaskdept = new ServiceTaskdept();
			@@ -1905,14 +2459,31 @@
			if (serviceSubtaskCountReq.getDrcode() != null && !serviceSubtaskCountReq.getDrcode().isEmpty()) {
			groupKey = drcode;
			} else {
			groupKey = "deptcode";
			// 2026-11 字段重命名后：deptcode 是在院科室（历史数据为空），
			// 出院科室已改名为 leaveldeptcode，分组必须用后者，
			// 否则 getSfStatisticsGroupKey 会返回 NULL，拼成 IN (NULL) 导致整表查空。
			groupKey = "leaveldeptcode";
			}
			} else if (serviceSubtaskCountReq.getStatisticaltype() != null && serviceSubtaskCountReq.getStatisticaltype() == 3) {
			// 病种统计：按任务ID分组，每个任务即一个病种随访任务
			groupKey = "taskid";
			}
			List<ServiceSubtaskStatistic> serviceSubtaskStatistics = new ArrayList<>();
			// 根据条件进行分组
			Map<String, List<ServiceSubtask>> collect = new HashMap<>();
			serviceSubtaskCountReq.setGroupKey(groupKey);
			List<String> groupKeyList = serviceSubtaskMapper.getSfStatisticsGroupKey(serviceSubtaskCountReq);
			/*
			* 分组键可能为 NULL（历史数据、或重命名后尚未回填的在院维度列），
			* 直接拼进 SQL 会变成 `AND IFNULL(列,'Unknown') IN (NULL)`，恒不成立，整张统计表为空。
			* 这里统一成 'Unknown'，与聚合 SQL 的 IFNULL(列,'Unknown') 口径对齐。
			*/
			if (groupKeyList != null) {
			groupKeyList = groupKeyList.stream()
			.map(key -> key == null ? "Unknown" : key)
			.distinct()
			.collect(Collectors.toList());
			}
			serviceSubtaskCountReq.setGroupKeyList(groupKeyList);
			List<ServiceSubtask> rawData = serviceSubtaskMapper.getSfStatistics(serviceSubtaskCountReq);
			switch (groupKey) {
			@@ -1927,10 +2498,14 @@
			collect = rawData.stream().collect(Collectors.groupingBy(subtask -> Optional.ofNullable(subtask.getManagementDoctorCode()).orElse("Unknown")));
			break;
			case "deptcode":
			case "leaveldeptcode":
			collect = rawData.stream().collect(Collectors.groupingBy(subtask -> Optional.ofNullable(subtask.getLeaveldeptcode()).orElse("Unknown")));
			break;
			case "leavehospitaldistrictcode":
			collect = rawData.stream().collect(Collectors.groupingBy(subtask -> Optional.ofNullable(subtask.getLeavehospitaldistrictcode()).orElse("Unknown")));
			break;
			case "taskid":
			collect = rawData.stream().collect(Collectors.groupingBy(subtask -> Optional.ofNullable(subtask.getTaskid()).map(String::valueOf).orElse("Unknown")));
			break;
			default:
			collect = rawData.stream().collect(Collectors.groupingBy(subtask -> Optional.ofNullable(subtask.getDrcode()).orElse("Unknown")));
			@@ -1944,6 +2519,9 @@
			continue;
			}
			ServiceSubtaskStatistic statistic = getStatistic(serviceSubtaskList, serviceSubtaskCountReq.getFollowUpCountStyle(), serviceSubtaskCountReq.getVisitCount());
			if ("taskid".equals(groupKey)) {
			applyTaskGroupInfo(statistic, serviceSubtaskList);
			}
			if (ObjectUtils.isNotEmpty(jsRates)) {
			Map<String, Object> jsRateMap = jsRates.get(collectKey);
			BigDecimal jsRate = new BigDecimal("0");
			@@ -2032,7 +2610,16 @@
			ssRate.setGroupKey(groupKey);
			ssRate.setGroupKeyList(groupKeyList);
			ssRate.setRateDay(serviceSubtaskCountReq.getRateDay());
			return serviceSubtaskMapper.selectTimelyRateBatch(ssRate);
			Map<String, Map<String, Object>> rateResult = serviceSubtaskMapper.selectTimelyRateBatch(ssRate);
			if (rateResult == null \|\| rateResult.isEmpty()) {
			return rateResult;
			}
			// taskid 为数值类型，MyBatis 返回的 Map key 可能是 Long，这里统一转成 String 与分组 key 对齐
			Map<String, Map<String, Object>> jsRates = new HashMap<>();
			for (Map.Entry<String, Map<String, Object>> entry : rateResult.entrySet()) {
			jsRates.put(String.valueOf(entry.getKey()), entry.getValue());
			}
			return jsRates;
			}

			/**
			@@ -2056,6 +2643,9 @@
			ServiceSubtaskStatistic totalRow = calculateTotalRow(sfStatistics);
			totalRow.setLeavehospitaldistrictname("总计");
			totalRow.setDeptname("总计");
			if (serviceSubtaskCountReq.getStatisticaltype() != null && serviceSubtaskCountReq.getStatisticaltype() == 3) {
			totalRow.setTaskName("总计");
			}
			sfStatistics.add(totalRow);
			}

			@@ -2154,6 +2744,22 @@
			return serviceSubtaskStatistics;
			}

			/**
			* 病种统计（按 taskid 分组）时补齐任务ID、任务名称和疾病病种。
			*
			* @param statistic 统计结果
			* @param serviceSubtaskList 当前任务分组下的子任务
			*/
			private void applyTaskGroupInfo(ServiceSubtaskStatistic statistic, List<ServiceSubtask> serviceSubtaskList) {
			if (statistic == null \|\| CollectionUtils.isEmpty(serviceSubtaskList)) {
			return;
			}
			ServiceSubtask first = serviceSubtaskList.get(0);
			statistic.setTaskId(first.getTaskid());
			statistic.setTaskName(first.getTaskName());
			statistic.setDiagType(first.getDiagType());
			}

			private ServiceSubtaskStatistic getStatistic(List<ServiceSubtask> serviceSubtaskList, String followUpCountStyle, Integer visitCount) {
			ServiceSubtaskStatistic serviceSubtaskStatistic = new ServiceSubtaskStatistic();

			@@ -2170,6 +2776,8 @@
			serviceSubtaskStatistic.setLeavehospitaldistrictcode(serviceSubtaskList.get(0).getLeavehospitaldistrictcode());
			serviceSubtaskStatistic.setDrcode(serviceSubtaskList.get(0).getDrcode());
			serviceSubtaskStatistic.setDrname(serviceSubtaskList.get(0).getDrname());
			//随访中心科室，用于统计再次随访推送到随访中心的人数
			String centerDept = sysConfigService.selectConfigByKey("sys.smartor.center.dept", serviceSubtaskList.get(0).getOrgid());
			//出院人次
			serviceSubtaskStatistic.setDischargeCount(serviceSubtaskList.size());
			for (ServiceSubtask serviceSubtask : serviceSubtaskList) {
			@@ -2184,9 +2792,31 @@
			if (serviceSubtask.getSendstate() != null && serviceSubtask.getSendstate() != 4) {
			serviceSubtaskStatistic.setFollowUpNeeded(serviceSubtaskStatistic.getFollowUpNeeded() + 1L);
			}
			//及时随访人次：已完成且未超时
			if (isTimelyFollowUp(serviceSubtask)) {
			serviceSubtaskStatistic.setTimelyFollowUp(serviceSubtaskStatistic.getTimelyFollowUp() + 1L);
			}

			//首次出院人次：visitCount = 1，作为再次随访推送率的分母
			if (serviceSubtask.getVisitCount() != null && serviceSubtask.getVisitCount() == 1) {
			serviceSubtaskStatistic.setFirstDischargeCount(serviceSubtaskStatistic.getFirstDischargeCount() + 1L);
			}
			//再次随访推送人数：首个再次随访（visitCount = 2）且执行科室为随访中心科室
			if (serviceSubtask.getVisitCount() != null && serviceSubtask.getVisitCount() == 2
			&& StringUtils.isNotEmpty(centerDept)
			&& StringUtils.equals(StringUtils.trim(centerDept), StringUtils.trim(serviceSubtask.getVisitDeptCode()))) {
			serviceSubtaskStatistic.setAgainFollowUpPushCount(serviceSubtaskStatistic.getAgainFollowUpPushCount() + 1L);
			}

			//人工已拨通总量
			if (ObjectUtils.isNotEmpty(serviceSubtask.getIsManuallyCalled())
			&& serviceSubtask.getIsManuallyCalled().equals(1L)) {
			serviceSubtaskStatistic.setManuallyCalled(serviceSubtaskStatistic.getManuallyCalled() + 1L);
			}

			//首次出院随访
			if (serviceSubtask.getVisitCount() != null && serviceSubtask.getVisitCount() == 1) {
			applyFirstFollowUpExtraStatistics(serviceSubtaskStatistic, serviceSubtask);
			//首次应随访
			if (serviceSubtask.getSendstate() != null && !serviceSubtask.getSendstate().equals(4L)) {
			serviceSubtaskStatistic.setNeedFollowUp(serviceSubtaskStatistic.getNeedFollowUp() + 1L);
			@@ -2308,6 +2938,7 @@
			}
			}//二次出院随访
			else if (serviceSubtask.getVisitCount() != null && serviceSubtask.getVisitCount() > 1) {
			applyAgainFollowUpExtraStatistics(serviceSubtaskStatistic, serviceSubtask);
			//再次应随访
			if (serviceSubtask.getSendstate() != null && serviceSubtask.getSendstate() != 4) {
			serviceSubtaskStatistic.setNeedFollowUpAgain(serviceSubtaskStatistic.getNeedFollowUpAgain() + 1L);
			@@ -2446,6 +3077,80 @@
			}

			/**
			* 是否属于「及时随访」：随访已完成且完成时状态为正常完成（未超时）。
			* <p>
			* finish_state：1-正常完成 2-延期完成 3-超时完成，只有 1 计入及时随访。
			*
			* @param serviceSubtask 随访子任务
			* @return true-计入及时随访人次
			*/
			private boolean isTimelyFollowUp(ServiceSubtask serviceSubtask) {
			return serviceSubtask.getSendstate() != null && serviceSubtask.getSendstate().equals(6L)
			&& serviceSubtask.getFinishState() != null && serviceSubtask.getFinishState().equals(1L);
			}

			/**
			* 市一统计口径：首次待随访、已发送及人工电话超时。
			*/
			private void applyFirstFollowUpExtraStatistics(ServiceSubtaskStatistic statistic, ServiceSubtask serviceSubtask) {
			if (serviceSubtask.getVisitCount() == null \|\| serviceSubtask.getVisitCount() != 1 \|\| serviceSubtask.getSendstate() == null) {
			return;
			}
			Long sendstate = serviceSubtask.getSendstate();
			if (sendstate.equals(3L)) {
			statistic.setSent(statistic.getSent() + 1L);
			}
			if (sendstate.equals(7L) && isManuallyNotCalled(serviceSubtask)) {
			statistic.setManualCallTimeout(statistic.getManualCallTimeout() + 1L);
			}
			if (sendstate.equals(1L) \|\| sendstate.equals(2L) \|\| sendstate.equals(3L) \|\| sendstate.equals(7L)) {
			statistic.setPendingFollowUpAll(statistic.getPendingFollowUpAll() + 1L);
			}
			if (sendstate.equals(1L) \|\| sendstate.equals(2L)) {
			statistic.setPendingFollowUpWaitSend(statistic.getPendingFollowUpWaitSend() + 1L);
			}
			if (sendstate.equals(3L) \|\| sendstate.equals(7L)) {
			statistic.setPendingFollowUpSent(statistic.getPendingFollowUpSent() + 1L);
			}
			}

			/**
			* 再次随访附加统计：待随访、已发送、人工电话超时及回院复诊复查（suggest=7）。
			*/
			private void applyAgainFollowUpExtraStatistics(ServiceSubtaskStatistic statistic, ServiceSubtask serviceSubtask) {
			if (serviceSubtask.getVisitCount() == null \|\| serviceSubtask.getVisitCount() <= 1) {
			return;
			}
			if (serviceSubtask.getSendstate() == null) {
			return;
			}
			Long sendstate = serviceSubtask.getSendstate();
			// 回院复诊复查：再次随访中按处理意见 suggest=7 统计
			if (StringUtils.equals("7", StringUtils.trim(serviceSubtask.getSuggest()))) {
			statistic.setSuggest7CountAgain(statistic.getSuggest7CountAgain() + 1L);
			}
			if (sendstate.equals(3L)) {
			statistic.setSentAgain(statistic.getSentAgain() + 1L);
			}
			if (sendstate.equals(7L) && isManuallyNotCalled(serviceSubtask)) {
			statistic.setManualCallTimeoutAgain(statistic.getManualCallTimeoutAgain() + 1L);
			}
			if (sendstate.equals(1L) \|\| sendstate.equals(2L) \|\| sendstate.equals(3L) \|\| sendstate.equals(7L)) {
			statistic.setPendingFollowUpAllAgain(statistic.getPendingFollowUpAllAgain() + 1L);
			}
			if (sendstate.equals(1L) \|\| sendstate.equals(2L)) {
			statistic.setPendingFollowUpWaitSendAgain(statistic.getPendingFollowUpWaitSendAgain() + 1L);
			}
			if (sendstate.equals(3L) \|\| sendstate.equals(7L)) {
			statistic.setPendingFollowUpSentAgain(statistic.getPendingFollowUpSentAgain() + 1L);
			}
			}

			private boolean isManuallyNotCalled(ServiceSubtask serviceSubtask) {
			return serviceSubtask.getIsManuallyCalled() != null && serviceSubtask.getIsManuallyCalled().equals(0L);
			}

			/**
			* 首次随访统计
			*
			* @param serviceSubtaskList
			@@ -2466,6 +3171,7 @@
			serviceSubtaskStatistic.setDischargeCount(serviceSubtaskList.size());

			for (ServiceSubtask serviceSubtask : serviceSubtaskList) {
			applyFirstFollowUpExtraStatistics(serviceSubtaskStatistic, serviceSubtask);
			//无需随访人次
			if (serviceSubtask.getSendstate() != null && serviceSubtask.getSendstate() == 4) {
			serviceSubtaskStatistic.setNonFollowUp(serviceSubtaskStatistic.getNonFollowUp() + 1L);
			@@ -2476,6 +3182,10 @@
			//应随访人次
			if (serviceSubtask.getSendstate() != null && serviceSubtask.getSendstate() != 4) {
			serviceSubtaskStatistic.setFollowUpNeeded(serviceSubtaskStatistic.getFollowUpNeeded() + 1L);
			}
			//及时随访人次：已完成且未超时
			if (isTimelyFollowUp(serviceSubtask)) {
			serviceSubtaskStatistic.setTimelyFollowUp(serviceSubtaskStatistic.getTimelyFollowUp() + 1L);
			}

			//首次出院随访
			@@ -2635,6 +3345,7 @@
			//出院人次
			serviceSubtaskStatistic.setDischargeCount(serviceSubtaskList.size());
			for (ServiceSubtask serviceSubtask : serviceSubtaskList) {
			applyAgainFollowUpExtraStatistics(serviceSubtaskStatistic, serviceSubtask);
			//无需随访人次
			if (serviceSubtask.getSendstate() != null && serviceSubtask.getSendstate() == 4) {
			serviceSubtaskStatistic.setNonFollowUp(serviceSubtaskStatistic.getNonFollowUp() + 1L);
			@@ -2645,6 +3356,10 @@
			//应随访人次
			if (serviceSubtask.getSendstate() != null && serviceSubtask.getSendstate() != 4) {
			serviceSubtaskStatistic.setFollowUpNeeded(serviceSubtaskStatistic.getFollowUpNeeded() + 1L);
			}
			//及时随访人次：已完成且未超时
			if (isTimelyFollowUp(serviceSubtask)) {
			serviceSubtaskStatistic.setTimelyFollowUp(serviceSubtaskStatistic.getTimelyFollowUp() + 1L);
			}

			//再次出院随访
			@@ -2901,7 +3616,8 @@
			serviceSubtaskStatistic.setDrname(serviceSubtaskList.get(0).getDrname());
			serviceSubtaskStatistic.setJoyCount(0);
			serviceSubtaskStatistic.setJoyAllCount(0);

			//出院人次
			serviceSubtaskStatistic.setDischargeCount(serviceSubtaskList.size());
			//获取随访统计
			if (subCounts == null) {
			subCounts = new ArrayList<>();
			@@ -3010,11 +3726,14 @@
			* 获取随访统计超链接
			* dischargeCountInfo
			* followUpNeededAllInfo - sendstate != 4 (1,2,3,5,6,7)
			* firstDischargeCountInfo - visitCount = 1
			* againFollowUpPushCountInfo - visitCount = 2 && visitDeptCode = sys.smartor.center.dept（随访中心科室）
			* nonFollowUpInfo - sendstate = 4
			* needFollowUpInfo - visitCount = 1 && sendstate != 4
			* pendingFollowUpInfo - visitCount = 1 && sendstate = 2
			* followUpSuccessInfo - visitCount = 1 && sendstate = 6
			* followUpFailInfo - visitCount = 1 && (sendstate = 5 \|\| sendstate = 7)
			* timelyFollowUpInfo - sendstate = 6 && finish_state = 1（沿用请求的 visitCount 口径）
			* manualInfo - visitCount = 1 && currentPreachForm = "1"
			* voiceInfo - visitCount = 1 && currentPreachForm = "3"
			* smsInfo - visitCount = 1 && currentPreachForm = "4"
			@@ -3043,6 +3762,18 @@
			* taskSituation4Info - taskSituation = 4
			* taskSituation5Info - taskSituation = 5
			* taskSituation6Info - taskSituation = 7
			* manuallyCalledInfo - isManuallyCalled = 1L
			* manualCallTimeoutInfo - visitCount = 1 && sendstate = 7 && isManuallyCalled = 0
			* manualCallTimeoutAgainInfo - visitCount > 1 && sendstate = 7 && isManuallyCalled = 0
			* pendingFollowUpAllInfo - visitCount = 1 && sendstate in (1,2,3,7)
			* pendingFollowUpAllAgainInfo - visitCount > 1 && sendstate in (1,2,3,7)
			* pendingFollowUpWaitSendInfo - visitCount = 1 && sendstate in (1,2)
			* pendingFollowUpWaitSendAgainInfo - visitCount > 1 && sendstate in (1,2)
			* pendingFollowUpSentInfo - visitCount = 1 && sendstate in (3,7)
			* pendingFollowUpSentAgainInfo - visitCount > 1 && sendstate in (3,7)
			* sentInfo - visitCount = 1 && sendstate = 3
			* sentAgainInfo - visitCount > 1 && sendstate = 3
			* suggest7CountAgainInfo - visitCount > 1 && suggest = 7
			* filterCountList - taskSituation = 6 && sendstate = 4
			*
			*/
			@@ -3050,7 +3781,10 @@
			public List<ServiceSubtask> getSfStatisticsHyperlink(ServiceSubtaskCountReq serviceSubtaskCountReq) {
			String hyperLinkInfoType = serviceSubtaskCountReq.getHyperLinkInfoType();
			if (StringUtils.isNotEmpty(hyperLinkInfoType)) {
			applyHyperLinkInfoType(serviceSubtaskCountReq, hyperLinkInfoType);
			if (!applyHyperLinkInfoType(serviceSubtaskCountReq, hyperLinkInfoType)) {
			// 下钻依赖的配置缺失时返回空明细，避免退化成无过滤条件的查询
			return new ArrayList<>();
			}
			}

			String followUpCountStyle = serviceSubtaskCountReq.getFollowUpCountStyle();
			@@ -3071,15 +3805,40 @@
			return serviceSubtasks;
			}

			private void applyHyperLinkInfoType(ServiceSubtaskCountReq serviceSubtaskCountReq, String hyperLinkInfoType) {
			private boolean applyHyperLinkInfoType(ServiceSubtaskCountReq serviceSubtaskCountReq, String hyperLinkInfoType) {
			//及时随访明细需要沿用请求的首次/再次口径
			Integer originVisitCount = serviceSubtaskCountReq.getVisitCount();
			serviceSubtaskCountReq.setVisitCount(null);
			serviceSubtaskCountReq.setSendstates(null);
			serviceSubtaskCountReq.setCurrentPreachform(null);
			serviceSubtaskCountReq.setExcep(null);
			serviceSubtaskCountReq.setTaskSituation(null);
			serviceSubtaskCountReq.setFinishState(null);
			serviceSubtaskCountReq.setSuggest(null);

			switch (hyperLinkInfoType) {
			case "dischargeCountInfo":
			break;
			case "firstDischargeCountInfo":
			//首次出院人次：visitCount = 1
			serviceSubtaskCountReq.setVisitCount(1);
			break;
			case "againFollowUpPushCountInfo": {
			//再次随访推送人数：visitCount = 2 且执行科室为随访中心科室
			String centerDept = sysConfigService.selectConfigByKey("sys.smartor.center.dept", serviceSubtaskCountReq.getOrgid());
			if (StringUtils.isBlank(centerDept)) {
			log.warn("获取再次随访推送明细失败，未配置随访中心科室参数 sys.smartor.center.dept, orgid={}", serviceSubtaskCountReq.getOrgid());
			return false;
			}
			serviceSubtaskCountReq.setVisitCount(2);
			serviceSubtaskCountReq.setVisitDeptCode(centerDept.trim());
			serviceSubtaskCountReq.setVisitDeptName(null);
			break;
			}
			case "timelyFollowUpInfo":
			serviceSubtaskCountReq.setVisitCount(originVisitCount);
			serviceSubtaskCountReq.setSendstates(new ArrayList<>(Collections.singletonList(6L)));
			serviceSubtaskCountReq.setFinishState(1L);
			break;
			case "followUpNeededAllInfo":
			serviceSubtaskCountReq.setSendstates(new ArrayList<>(Arrays.asList(1L, 2L, 3L, 5L, 6L, 7L)));
			@@ -3115,7 +3874,7 @@
			serviceSubtaskCountReq.setVisitCount(1);
			serviceSubtaskCountReq.setCurrentPreachform("4");
			break;
			case "wechatInfo":
			case "weChatInfo":
			serviceSubtaskCountReq.setVisitCount(1);
			serviceSubtaskCountReq.setCurrentPreachform("5");
			break;
			@@ -3134,7 +3893,7 @@
			serviceSubtaskCountReq.setSendstates(new ArrayList<>(Collections.singletonList(6L)));
			serviceSubtaskCountReq.setCurrentPreachform("4");
			break;
			case "wechatSuccessInfo":
			case "weChatSuccessInfo":
			serviceSubtaskCountReq.setVisitCount(1);
			serviceSubtaskCountReq.setSendstates(new ArrayList<>(Collections.singletonList(6L)));
			serviceSubtaskCountReq.setCurrentPreachform("5");
			@@ -3171,7 +3930,7 @@
			serviceSubtaskCountReq.setVisitCount(2);
			serviceSubtaskCountReq.setCurrentPreachform("4");
			break;
			case "wechatAgainInfo":
			case "weChatAgainInfo":
			serviceSubtaskCountReq.setVisitCount(2);
			serviceSubtaskCountReq.setCurrentPreachform("5");
			break;
			@@ -3190,7 +3949,7 @@
			serviceSubtaskCountReq.setSendstates(new ArrayList<>(Collections.singletonList(6L)));
			serviceSubtaskCountReq.setCurrentPreachform("4");
			break;
			case "wechatAgainSuccessInfo":
			case "weChatAgainSuccessInfo":
			serviceSubtaskCountReq.setVisitCount(2);
			serviceSubtaskCountReq.setSendstates(new ArrayList<>(Collections.singletonList(6L)));
			serviceSubtaskCountReq.setCurrentPreachform("5");
			@@ -3198,6 +3957,11 @@
			case "abnormalAgainInfo":
			serviceSubtaskCountReq.setVisitCount(2);
			serviceSubtaskCountReq.setExcep("1");
			break;
			case "suggest7CountAgainInfo":
			// 再次随访回院复诊复查：visitCount > 1 且 suggest = 7
			serviceSubtaskCountReq.setVisitCount(2);
			serviceSubtaskCountReq.setSuggest("7");
			break;
			case "taskSituation1Info":
			serviceSubtaskCountReq.setTaskSituation(1);
			@@ -3221,9 +3985,55 @@
			serviceSubtaskCountReq.setTaskSituation(6);
			serviceSubtaskCountReq.setSendstates(new ArrayList<>(Collections.singletonList(4L)));
			break;
			case "manuallyCalledInfo":
			serviceSubtaskCountReq.setIsManuallyCalled(1L);
			break;
			case "manualCallTimeoutInfo":
			serviceSubtaskCountReq.setVisitCount(1);
			serviceSubtaskCountReq.setSendstates(new ArrayList<>(Collections.singletonList(7L)));
			serviceSubtaskCountReq.setIsManuallyCalled(0L);
			break;
			case "manualCallTimeoutAgainInfo":
			serviceSubtaskCountReq.setVisitCount(2);
			serviceSubtaskCountReq.setSendstates(new ArrayList<>(Collections.singletonList(7L)));
			serviceSubtaskCountReq.setIsManuallyCalled(0L);
			break;
			case "pendingFollowUpAllInfo":
			serviceSubtaskCountReq.setVisitCount(1);
			serviceSubtaskCountReq.setSendstates(new ArrayList<>(Arrays.asList(1L, 2L, 3L, 7L)));
			break;
			case "pendingFollowUpAllAgainInfo":
			serviceSubtaskCountReq.setVisitCount(2);
			serviceSubtaskCountReq.setSendstates(new ArrayList<>(Arrays.asList(1L, 2L, 3L, 7L)));
			break;
			case "pendingFollowUpWaitSendInfo":
			serviceSubtaskCountReq.setVisitCount(1);
			serviceSubtaskCountReq.setSendstates(new ArrayList<>(Arrays.asList(1L, 2L)));
			break;
			case "pendingFollowUpWaitSendAgainInfo":
			serviceSubtaskCountReq.setVisitCount(2);
			serviceSubtaskCountReq.setSendstates(new ArrayList<>(Arrays.asList(1L, 2L)));
			break;
			case "pendingFollowUpSentInfo":
			serviceSubtaskCountReq.setVisitCount(1);
			serviceSubtaskCountReq.setSendstates(new ArrayList<>(Arrays.asList(3L, 7L)));
			break;
			case "pendingFollowUpSentAgainInfo":
			serviceSubtaskCountReq.setVisitCount(2);
			serviceSubtaskCountReq.setSendstates(new ArrayList<>(Arrays.asList(3L, 7L)));
			break;
			case "sentInfo":
			serviceSubtaskCountReq.setVisitCount(1);
			serviceSubtaskCountReq.setSendstates(new ArrayList<>(Collections.singletonList(3L)));
			break;
			case "sentAgainInfo":
			serviceSubtaskCountReq.setVisitCount(2);
			serviceSubtaskCountReq.setSendstates(new ArrayList<>(Collections.singletonList(3L)));
			break;
			default:
			break;
			}
			return true;
			}

			/**
			@@ -3233,7 +4043,7 @@
			* @return
			*/
			@Override
			@Cacheable(value = "getSfStatisticsScript", key = "T(org.springframework.util.DigestUtils).md5DigestAsHex(#serviceSubtaskCountReq.toString().getBytes())", unless = "#result == null or #result.isEmpty()")
			// @Cacheable(value = "getSfStatisticsScript", key = "T(org.springframework.util.DigestUtils).md5DigestAsHex(#serviceSubtaskCountReq.toString().getBytes())", unless = "#result == null or #result.isEmpty()")
			public List<ServiceSubtaskStatistic> getSfStatisticsScript(ServiceSubtaskCountReq serviceSubtaskCountReq) {
			log.info("getSfStatisticsScript的入参为：{}", serviceSubtaskCountReq);
			List<ServiceSubtaskStatistic> serviceSubtaskStatistics = new ArrayList<>();
			@@ -3255,6 +4065,15 @@
			} else if (serviceSubtaskCountReq.getDeptcodes() != null && !serviceSubtaskCountReq.getDeptcodes().isEmpty()) {
			// 历史入参 deptcodes 表示离院科室
			groupKey = hasDrcode ? "drcode" : "leaveldeptcode";
			} else if (serviceSubtaskCountReq.getStatisticaltype() != null && serviceSubtaskCountReq.getStatisticaltype() == 1) {
			// 历史入参（市一等老前端只传 statisticaltype）：1 = 病区统计
			groupKey = hasDrcode ? "drcode" : "leavehospitaldistrictcode";
			} else if (serviceSubtaskCountReq.getStatisticaltype() != null && serviceSubtaskCountReq.getStatisticaltype() == 2) {
			// 历史入参：2 = 科室统计（原 deptcode 即现在的离院科室 leaveldeptcode）
			groupKey = hasDrcode ? "drcode" : "leaveldeptcode";
			} else if (serviceSubtaskCountReq.getStatisticaltype() != null && serviceSubtaskCountReq.getStatisticaltype() == 3) {
			// 病种统计：按任务ID分组，每个任务即一个病种随访任务
			groupKey = "taskid";
			}
			serviceSubtaskCountReq.setGroupKey(groupKey);
			// 分组列与过滤列保持一致：离院科室 leaveldeptcode、在院科室 deptcode
			@@ -3298,6 +4117,35 @@
			List<ServiceSubtaskStatistic> sumStatistics = serviceSubtaskMapper.getSfStatisticsScriptSum(serviceSubtaskCountReq);
			if (CollectionUtils.isEmpty(sumStatistics)) {
			return serviceSubtaskStatistics;
			}

			/*
			* 病种统计（按 taskid 分组）时补齐任务ID、任务名称和疾病病种。
			* 聚合 SQL 已返回 taskid/task_name，这里再补 diag_type。
			*/
			if ("taskid".equals(groupKey)) {
			Map<Long, String> diagTypeCache = new HashMap<>();
			for (ServiceSubtaskStatistic statistic : sumStatistics) {
			Long taskId = statistic.getTaskId();
			if (taskId == null && StringUtils.isNotEmpty(statistic.getGroupCode())) {
			try {
			taskId = Long.valueOf(statistic.getGroupCode());
			} catch (NumberFormatException ignore) {
			// 历史数据可能不是数值 taskid，保持原分组键即可
			}
			}
			statistic.setTaskId(taskId);
			if (StringUtils.isEmpty(statistic.getTaskName())) {
			statistic.setTaskName(statistic.getGroupName());
			}
			if (taskId != null) {
			if (!diagTypeCache.containsKey(taskId)) {
			ServiceTask task = serviceTaskService.selectServiceTaskByTaskid(taskId);
			diagTypeCache.put(taskId, task == null ? null : task.getDiagType());
			}
			statistic.setDiagType(diagTypeCache.get(taskId));
			}
			}
			}

			/*
			@@ -3441,8 +4289,7 @@
			}

			@Override
			public Map<String, ServiceSubtaskScriptCount> getSfStatisticsScriptDetails(ServiceSubtaskCountReq serviceSubtaskCountReq) {
			Map<String, ServiceSubtaskScriptCount> result = new HashMap<>();
			public Map<String, Object> getSfStatisticsScriptDetails(ServiceSubtaskCountReq serviceSubtaskCountReq) {
			List<ServiceSubtaskScriptCount> allCounts = new ArrayList<>();
			List<ServiceSubtaskScriptCount> allItemCounts = new ArrayList<>();
			String type = serviceSubtaskCountReq.getType();
			@@ -3466,7 +4313,23 @@
			allItemCounts = serviceSubtaskMapper.getSfStatisticsScriptItemDetails(serviceSubtaskCountReq);
			}

			for (ServiceSubtaskScriptCount count : allCounts) {
			//返回结构是 Map，且不传 type 时会执行两条 SQL，PageHelper 没法对整体分页，
			//所以在题目合并完成之后按题目（scriptid）在这里分页，保证 total 和每页数据都是题目维度的。
			allCounts.sort(Comparator
			.comparing(ServiceSubtaskScriptCount::getSubtaskType, Comparator.nullsLast(String::compareTo))
			.thenComparing(ServiceSubtaskScriptCount::getScriptid, Comparator.nullsLast(Long::compareTo)));

			int pageNum = ObjectUtils.isNotEmpty(serviceSubtaskCountReq.getPageNum()) && serviceSubtaskCountReq.getPageNum() > 0
			? serviceSubtaskCountReq.getPageNum() : 1;
			int pageSize = ObjectUtils.isNotEmpty(serviceSubtaskCountReq.getPageSize()) && serviceSubtaskCountReq.getPageSize() > 0
			? serviceSubtaskCountReq.getPageSize() : 10;
			int total = allCounts.size();
			int fromIndex = (int) Math.min((long) (pageNum - 1) * pageSize, total);
			int toIndex = Math.min(fromIndex + pageSize, total);
			List<ServiceSubtaskScriptCount> pageCounts = allCounts.subList(fromIndex, toIndex);

			Map<String, ServiceSubtaskScriptCount> pageData = new LinkedHashMap<>();
			for (ServiceSubtaskScriptCount count : pageCounts) {
			Map<String, ServiceSubtaskScriptCount> itemCountMap = new HashMap<>();
			//问卷加上空白选项
			if (ObjectUtils.isNotEmpty(count.getTemplateid()) && ObjectUtils.isNotEmpty(count.getSubtaskType()) && count.getSubtaskType().equals("2")) {
			@@ -3497,32 +4360,125 @@
			}
			}
			allItemCounts.forEach(itemCount -> {
			if (ObjectUtils.isNotEmpty(count.getScriptid()) && ObjectUtils.isNotEmpty(itemCount.getScriptid())) {
			if (count.getScriptid().equals(itemCount.getScriptid())) {
			//放入统计信息
			itemCount.setScriptContent(count.getScriptContent());
			itemCount.setScriptType(count.getScriptType());
			itemCount.setSubtaskType(count.getSubtaskType());
			itemCount.setCompletedQuantity(count.getCompletedQuantity());
			itemCount.setAllQuantity(count.getAllQuantity());
			itemCount.setCompletedPercentage(count.getCompletedPercentage());
			itemCount.setTemplateid(count.getTemplateid());
			//计算选择比例
			int chosenQuantity = ObjectUtils.isNotEmpty(itemCount.getChosenQuantity()) ? itemCount.getChosenQuantity() : 0;
			int completedQuantity = itemCount.getCompletedQuantity();
			if (ObjectUtils.isNotEmpty(completedQuantity) && completedQuantity != 0) {
			BigDecimal chosenPercentage = (new BigDecimal(chosenQuantity)).divide(new BigDecimal(completedQuantity), 2, RoundingMode.HALF_UP);
			itemCount.setChosenPercentage(chosenPercentage.toString());
			}
			itemCountMap.put(itemCount.getOptionText(), itemCount);
			//明细行已按“题目内容+任务类型”聚合并带出 script_content，不能用 scriptid 匹配：
			//同一道题会被复制到多个任务模板，每个模板的 scriptid 都不同
			boolean sameQuestion = ObjectUtils.isNotEmpty(count.getScriptContent())
			&& ObjectUtils.isNotEmpty(itemCount.getScriptContent())
			&& count.getScriptContent().equals(itemCount.getScriptContent())
			&& Objects.equals(count.getSubtaskType(), itemCount.getSubtaskType());
			if (sameQuestion) {
			//放入统计信息
			itemCount.setScriptContent(count.getScriptContent());
			itemCount.setScriptType(count.getScriptType());
			itemCount.setSubtaskType(count.getSubtaskType());
			itemCount.setCompletedQuantity(count.getCompletedQuantity());
			itemCount.setAllQuantity(count.getAllQuantity());
			itemCount.setCompletedPercentage(count.getCompletedPercentage());
			itemCount.setTemplateid(count.getTemplateid());
			//计算选择比例
			int chosenQuantity = ObjectUtils.isNotEmpty(itemCount.getChosenQuantity()) ? itemCount.getChosenQuantity() : 0;
			int completedQuantity = itemCount.getCompletedQuantity();
			if (ObjectUtils.isNotEmpty(completedQuantity) && completedQuantity != 0) {
			BigDecimal chosenPercentage = (new BigDecimal(chosenQuantity)).divide(new BigDecimal(completedQuantity), 2, RoundingMode.HALF_UP);
			itemCount.setChosenPercentage(chosenPercentage.toString());
			}
			itemCountMap.put(itemCount.getOptionText(), itemCount);
			}
			});
			List<ServiceSubtaskScriptCount> itemCounts = new ArrayList<>(itemCountMap.values());
			count.setDetails(itemCounts);
			result.put(count.getScriptid().toString(), count);
			pageData.put(count.getScriptid().toString(), count);
			}
			Map<String, Object> result = new HashMap<>();
			// total 是题目总数（已按题目合并），rows/data 是当前页数据
			result.put("total", total);
			result.put("pageNum", pageNum);
			result.put("pageSize", pageSize);
			result.put("rows", new ArrayList<>(pageCounts));
			result.put("data", pageData);
			return result;
			}

			/**
			* 问题选项数字下钻：返回选择了指定选项的 service_subtask 列表。
			* <p>
			* 统计明细中的选项数量来自 service_subtask_detail 的
			* IFNULL(matchedtext, asrtext)，因此下钻必须使用同一题目的相同选项进行匹配。
			*
			* @param serviceSubtaskCountReq 下钻条件
			* @return service_subtask 列表
			*/
			@Override
			public List<ServiceSubtask> getSfStatisticsScriptDetailsHyperlink(ServiceSubtaskCountReq serviceSubtaskCountReq) {
			log.info("getSfStatisticsScriptDetailsHyperlink的入参为：{}", serviceSubtaskCountReq);
			if (serviceSubtaskCountReq == null) {
			return new ArrayList<>();
			}
			// 兼容前端直接回传统计明细行中的 subtaskType
			if (StringUtils.isBlank(serviceSubtaskCountReq.getType())
			&& StringUtils.isNotBlank(serviceSubtaskCountReq.getSubtaskType())) {
			serviceSubtaskCountReq.setType(serviceSubtaskCountReq.getSubtaskType());
			}
			resolveScriptContentAndType(serviceSubtaskCountReq);
			if (StringUtils.isBlank(serviceSubtaskCountReq.getScriptContent())
			&& serviceSubtaskCountReq.getScriptid() == null) {
			log.warn("getSfStatisticsScriptDetailsHyperlink-题目scriptid和scriptContent均为空，返回空列表");
			return new ArrayList<>();
			}
			if (serviceSubtaskCountReq.getOptionText() == null) {
			log.warn("getSfStatisticsScriptDetailsHyperlink-选项optionText为空，返回空列表");
			return new ArrayList<>();
			}
			return serviceSubtaskMapper.getSfStatisticsScriptDetailsHyperlink(serviceSubtaskCountReq);
			}

			/**
			* 根据 scriptid 补齐题目内容和任务类型。
			* <p>
			* 统计明细按“题目内容 + 任务类型”合并，同一道题复制到多个任务模板时 scriptid 可能不同，
			* 因此优先按题目内容下钻；只有查不到题目内容时才退化为 scriptid 精确匹配。
			*/
			private void resolveScriptContentAndType(ServiceSubtaskCountReq serviceSubtaskCountReq) {
			if (serviceSubtaskCountReq.getScriptid() == null) {
			return;
			}
			// 已有题目内容和任务类型时无需再查模板问题表
			if (StringUtils.isNotBlank(serviceSubtaskCountReq.getScriptContent())
			&& StringUtils.isNotBlank(serviceSubtaskCountReq.getType())) {
			return;
			}

			String type = serviceSubtaskCountReq.getType();
			if (StringUtils.isBlank(type) \|\| "1".equals(type)) {
			IvrTaskTemplateScript ivrTaskTemplateScript =
			iIvrTaskTemplateScriptService.selectIvrTaskTemplateScriptByID(serviceSubtaskCountReq.getScriptid());
			if (ObjectUtils.isNotEmpty(ivrTaskTemplateScript)) {
			if (StringUtils.isBlank(serviceSubtaskCountReq.getType())) {
			serviceSubtaskCountReq.setType("1");
			}
			if (StringUtils.isBlank(serviceSubtaskCountReq.getScriptContent())) {
			serviceSubtaskCountReq.setScriptContent(ivrTaskTemplateScript.getScriptContent());
			}
			return;
			}
			// 明确指定了语音类型时不再尝试问卷表
			if (StringUtils.isNotBlank(type)) {
			return;
			}
			}

			if (StringUtils.isBlank(serviceSubtaskCountReq.getType()) \|\| "2".equals(type)) {
			SvyTaskTemplateScript svyTaskTemplateScript =
			svyTaskTemplateScriptService.selectSvyTaskTemplateScriptByID(serviceSubtaskCountReq.getScriptid());
			if (ObjectUtils.isNotEmpty(svyTaskTemplateScript)) {
			if (StringUtils.isBlank(serviceSubtaskCountReq.getType())) {
			serviceSubtaskCountReq.setType("2");
			}
			if (StringUtils.isBlank(serviceSubtaskCountReq.getScriptContent())) {
			serviceSubtaskCountReq.setScriptContent(svyTaskTemplateScript.getScriptContent());
			}
			}
			}
			}

			/**
			@@ -3536,6 +4492,8 @@

			// 初始化数值字段
			total.setDischargeCount(0);
			total.setFirstDischargeCount(0L);
			total.setAgainFollowUpPushCount(0L);
			total.setNonFollowUp(0L);
			total.setFilterCount(0L);
			total.setFollowUpNeeded(0L);
			@@ -3543,14 +4501,26 @@
			total.setPendingFollowUp(0L);
			total.setFollowUpSuccess(0L);
			total.setFollowUpFail(0L);
			total.setTimelyFollowUp(0L);
			total.setManual(0L);
			total.setSms(0L);
			total.setWeChat(0L);
			total.setAbnormal(0L);
			total.setNeedFollowUpAgain(0L);
			total.setPendingFollowUpAgain(0L);
			total.setManualCallTimeout(0L);
			total.setManualCallTimeoutAgain(0L);
			total.setPendingFollowUpAll(0L);
			total.setPendingFollowUpAllAgain(0L);
			total.setPendingFollowUpWaitSend(0L);
			total.setPendingFollowUpWaitSendAgain(0L);
			total.setPendingFollowUpSent(0L);
			total.setPendingFollowUpSentAgain(0L);
			total.setSent(0L);
			total.setSentAgain(0L);
			total.setFollowUpSuccessAgain(0L);
			total.setFollowUpFailAgain(0L);
			total.setSuggest7CountAgain(0L);
			total.setManualAgain(0L);
			total.setSmsAgain(0L);
			total.setWeChatAgain(0L);
			@@ -3567,6 +4537,8 @@
			if (stat.getDischargeCount() != null) {
			total.setDischargeCount(total.getDischargeCount() + stat.getDischargeCount());
			}
			total.setFirstDischargeCount(total.getFirstDischargeCount() + (stat.getFirstDischargeCount() != null ? stat.getFirstDischargeCount() : 0L));
			total.setAgainFollowUpPushCount(total.getAgainFollowUpPushCount() + (stat.getAgainFollowUpPushCount() != null ? stat.getAgainFollowUpPushCount() : 0L));
			total.setNonFollowUp(total.getNonFollowUp() + (stat.getNonFollowUp() != null ? stat.getNonFollowUp() : 0L));
			total.setFilterCount(total.getFilterCount() + (stat.getFilterCount() != null ? stat.getFilterCount() : 0L));
			total.setFollowUpNeeded(total.getFollowUpNeeded() + (stat.getFollowUpNeeded() != null ? stat.getFollowUpNeeded() : 0L));
			@@ -3574,14 +4546,26 @@
			total.setPendingFollowUp(total.getPendingFollowUp() + (stat.getPendingFollowUp() != null ? stat.getPendingFollowUp() : 0L));
			total.setFollowUpSuccess(total.getFollowUpSuccess() + (stat.getFollowUpSuccess() != null ? stat.getFollowUpSuccess() : 0L));
			total.setFollowUpFail(total.getFollowUpFail() + (stat.getFollowUpFail() != null ? stat.getFollowUpFail() : 0L));
			total.setTimelyFollowUp(total.getTimelyFollowUp() + (stat.getTimelyFollowUp() != null ? stat.getTimelyFollowUp() : 0L));
			total.setManual(total.getManual() + (stat.getManual() != null ? stat.getManual() : 0L));
			total.setSms(total.getSms() + (stat.getSms() != null ? stat.getSms() : 0L));
			total.setWeChat(total.getWeChat() + (stat.getWeChat() != null ? stat.getWeChat() : 0L));
			total.setAbnormal(total.getAbnormal() + (stat.getAbnormal() != null ? stat.getAbnormal() : 0L));
			total.setNeedFollowUpAgain(total.getNeedFollowUpAgain() + (stat.getNeedFollowUpAgain() != null ? stat.getNeedFollowUpAgain() : 0L));
			total.setPendingFollowUpAgain(total.getPendingFollowUpAgain() + (stat.getPendingFollowUpAgain() != null ? stat.getPendingFollowUpAgain() : 0L));
			total.setManualCallTimeout(total.getManualCallTimeout() + (stat.getManualCallTimeout() != null ? stat.getManualCallTimeout() : 0L));
			total.setManualCallTimeoutAgain(total.getManualCallTimeoutAgain() + (stat.getManualCallTimeoutAgain() != null ? stat.getManualCallTimeoutAgain() : 0L));
			total.setPendingFollowUpAll(total.getPendingFollowUpAll() + (stat.getPendingFollowUpAll() != null ? stat.getPendingFollowUpAll() : 0L));
			total.setPendingFollowUpAllAgain(total.getPendingFollowUpAllAgain() + (stat.getPendingFollowUpAllAgain() != null ? stat.getPendingFollowUpAllAgain() : 0L));
			total.setPendingFollowUpWaitSend(total.getPendingFollowUpWaitSend() + (stat.getPendingFollowUpWaitSend() != null ? stat.getPendingFollowUpWaitSend() : 0L));
			total.setPendingFollowUpWaitSendAgain(total.getPendingFollowUpWaitSendAgain() + (stat.getPendingFollowUpWaitSendAgain() != null ? stat.getPendingFollowUpWaitSendAgain() : 0L));
			total.setPendingFollowUpSent(total.getPendingFollowUpSent() + (stat.getPendingFollowUpSent() != null ? stat.getPendingFollowUpSent() : 0L));
			total.setPendingFollowUpSentAgain(total.getPendingFollowUpSentAgain() + (stat.getPendingFollowUpSentAgain() != null ? stat.getPendingFollowUpSentAgain() : 0L));
			total.setSent(total.getSent() + (stat.getSent() != null ? stat.getSent() : 0L));
			total.setSentAgain(total.getSentAgain() + (stat.getSentAgain() != null ? stat.getSentAgain() : 0L));
			total.setFollowUpSuccessAgain(total.getFollowUpSuccessAgain() + (stat.getFollowUpSuccessAgain() != null ? stat.getFollowUpSuccessAgain() : 0L));
			total.setFollowUpFailAgain(total.getFollowUpFailAgain() + (stat.getFollowUpFailAgain() != null ? stat.getFollowUpFailAgain() : 0L));
			total.setSuggest7CountAgain(total.getSuggest7CountAgain() + (stat.getSuggest7CountAgain() != null ? stat.getSuggest7CountAgain() : 0L));
			total.setManualAgain(total.getManualAgain() + (stat.getManualAgain() != null ? stat.getManualAgain() : 0L));
			total.setSmsAgain(total.getSmsAgain() + (stat.getSmsAgain() != null ? stat.getSmsAgain() : 0L));
			total.setWeChatAgain(total.getWeChatAgain() + (stat.getWeChatAgain() != null ? stat.getWeChatAgain() : 0L));
			@@ -3904,6 +4888,184 @@
			}
			}

			/**
			* 微信公众号已领取未填写：按题目默认选项补齐当前子任务，并将当前子任务完成。
			* <p>
			* 所有查询、明细写入、状态更新都只使用当前 subid，避免影响其他任务/子任务。
			*/
			@Override
			@Transactional(rollbackFor = Exception.class)
			public Boolean completeWechatClaimedByDefault(ServiceSubtask serviceSubtask) {
			if (serviceSubtask == null \|\| serviceSubtask.getId() == null) {
			return false;
			}

			// 重新读取当前子任务，所有判断只针对这一个 subid
			ServiceSubtask current = serviceSubtaskMapper.selectServiceSubtaskById(serviceSubtask.getId());
			if (current == null) {
			return false;
			}
			// 只处理：丽水中医院、问卷、当前方式公众号、已领取、未提交
			// 其他医院 orgid 不匹配时直接返回 false，继续走原补偿逻辑。
			if (!IServiceSubtaskService.WECHAT_DEFAULT_COMPLETE_ORGID.equals(current.getOrgid())
			\|\| !"2".equals(current.getType())
			\|\| !"5".equals(current.getCurrentPreachform())
			\|\| !Long.valueOf(1L).equals(current.getSendstate())
			\|\| Long.valueOf(1L).equals(current.getSubmit())) {
			return false;
			}

			// 查询当前子任务自己的公众号发送方式，必须是已发送(2)或已领取(3)
			ServiceSubtaskPreachform query = new ServiceSubtaskPreachform();
			query.setSubid(current.getId());
			query.setTaskid(current.getTaskid());
			query.setPreachform("5");
			List<ServiceSubtaskPreachform> preachforms = taskPreachformPort.selectServiceSubtaskPreachformList(query);
			if (CollectionUtils.isEmpty(preachforms)) {
			return false;
			}
			ServiceSubtaskPreachform currentPreachform = preachforms.stream()
			.filter(item -> "2".equals(item.getSendstate()) \|\| "3".equals(item.getSendstate()))
			.findFirst().orElse(null);
			if (currentPreachform == null) {
			return false;
			}

			// 只给当前 subid 补齐默认选项；至少有一题默认选项才继续
			int filled = fillWechatDefaultDetailForCurrentSubtask(current);
			if (filled <= 0) {
			log.info("【微信公众号默认完成】subid：{} 没有可填充的默认选项，跳过", current.getId());
			return false;
			}

			// 当前公众号发送方式：已发送/已领取 -> 完成(9)
			ServiceSubtaskPreachform updatePreachform = new ServiceSubtaskPreachform();
			updatePreachform.setId(currentPreachform.getId());
			updatePreachform.setSubid(current.getId());
			updatePreachform.setPreachform("5");
			updatePreachform.setOrgid(current.getOrgid());
			updatePreachform.setRemark("已领取未填写，按默认选项完成");
			int preachformUpdated = taskPreachformPort.updateWechatPreachformComplete(updatePreachform);
			if (preachformUpdated == 0) {
			throw new BaseException("微信公众号默认完成失败：发送方式状态已变化，subid=" + current.getId());
			}

			// 当前子任务：已领取(1) -> 完成(6)，只更新这一个 subid
			ServiceSubtask complete = new ServiceSubtask();
			complete.setId(current.getId());
			complete.setOrgid(current.getOrgid());
			complete.setFinishtime(new Date());
			complete.setResult("success");
			complete.setRemark("已领取未填写，按默认选项完成");
			int subtaskUpdated = serviceSubtaskMapper.updateWechatDefaultComplete(complete);
			if (subtaskUpdated == 0) {
			throw new BaseException("微信公众号默认完成失败：子任务状态已变化，subid=" + current.getId());
			}

			log.info("【微信公众号默认完成】subid：{}，已按默认选项完成，填充题目数：{}", current.getId(), filled);
			return true;
			}

			/**
			* 仅给当前子任务补齐问卷单选/多选题中 default_value=2 的选项。
			* 已有非空答案的题目跳过，不覆盖患者已填写内容。
			*
			* @return 实际填充（或此前已由系统默认填充）的题目数
			*/
			private int fillWechatDefaultDetailForCurrentSubtask(ServiceSubtask serviceSubtask) {
			Long templateId = serviceSubtask.getTemplateid();
			ServiceTask serviceTask = serviceTaskService.selectServiceTaskByTaskid(serviceSubtask.getTaskid());
			if (templateId == null && serviceTask != null) {
			templateId = serviceTask.getTemplateid();
			}
			if (templateId == null) {
			return 0;
			}

			SvyTaskTemplateScript scriptQuery = new SvyTaskTemplateScript();
			scriptQuery.setTemplateID(templateId);
			List<SvyTaskTemplateScript> scripts = svyTaskTemplateScriptService.selectSvyTaskTemplateScriptList(scriptQuery);
			if (CollectionUtils.isEmpty(scripts)) {
			return 0;
			}

			int filled = 0;
			for (SvyTaskTemplateScript script : scripts) {
			SvyTaskTemplateScriptVO scriptVO = DtoConversionUtils.sourceToTarget(script, SvyTaskTemplateScriptVO.class);
			SvyTaskTemplateScriptVO scriptWithOptions = svyTaskTemplateScriptService.selectInfoByCondition(scriptVO);
			if (scriptWithOptions == null
			\|\| scriptWithOptions.getId() == null
			\|\| CollectionUtils.isEmpty(scriptWithOptions.getSvyTaskTemplateTargetoptions())
			\|\| (!"1".equals(scriptWithOptions.getScriptType()) && !"2".equals(scriptWithOptions.getScriptType()))) {
			continue;
			}

			List<SvyTaskTemplateTargetoption> options = scriptWithOptions.getSvyTaskTemplateTargetoptions();
			List<SvyTaskTemplateTargetoption> defaultOptions = options.stream()
			.filter(option -> option.getDefaultValue() != null && option.getDefaultValue() == 2L)
			.filter(option -> StringUtils.isNotBlank(option.getOptioncontent()))
			.collect(Collectors.toList());
			if (CollectionUtils.isEmpty(defaultOptions)) {
			continue;
			}

			// 已有非空答案则不覆盖，避免影响患者已填写内容
			ServiceSubtaskDetail detailQuery = new ServiceSubtaskDetail();
			detailQuery.setSubId(serviceSubtask.getId());
			detailQuery.setScriptid(scriptWithOptions.getId());
			List<ServiceSubtaskDetail> existingDetails = serviceSubtaskDetailMapper.selectServiceSubtaskDetailList(detailQuery);
			ServiceSubtaskDetail existing = CollectionUtils.isNotEmpty(existingDetails) ? existingDetails.get(0) : null;
			if (existing != null
			&& (StringUtils.isNotBlank(existing.getAsrtext()) \|\| StringUtils.isNotBlank(existing.getMatchedtext()))) {
			// 之前已由系统默认填充过的，计入已填充，保证重试幂等
			if ("DEFAULT".equals(existing.getOperate())) {
			filled++;
			}
			continue;
			}

			String targetValue = options.stream()
			.map(SvyTaskTemplateTargetoption::getOptioncontent)
			.filter(StringUtils::isNotBlank)
			.collect(Collectors.joining("&"));
			String defaultValue = defaultOptions.stream()
			.map(SvyTaskTemplateTargetoption::getOptioncontent)
			.collect(Collectors.joining("&"));

			ServiceSubtaskDetail detail = new ServiceSubtaskDetail();
			detail.setSubId(serviceSubtask.getId());
			detail.setTaskid(serviceSubtask.getTaskid());
			detail.setPatid(serviceSubtask.getPatid());
			detail.setScriptid(scriptWithOptions.getId());
			detail.setTemplatequestionnum(scriptWithOptions.getId());
			detail.setQuestiontext(scriptWithOptions.getScriptContent());
			detail.setCategoryid(scriptWithOptions.getCategoryid());
			detail.setTargetid(scriptWithOptions.getTargetid() != null ? scriptWithOptions.getTargetid().intValue() : null);
			detail.setValueType(scriptWithOptions.getScriptType());
			detail.setTargetvalue(targetValue);
			detail.setAsrtext(defaultValue);
			detail.setMatchedtext(defaultValue);
			detail.setOperate("DEFAULT");
			detail.setTemplateType(2);
			detail.setLibTemplateid(serviceSubtask.getLibtemplateid() != null ? serviceSubtask.getLibtemplateid().intValue() : null);
			detail.setTemplateid(templateId.toString());
			detail.setGuid(scriptWithOptions.getGuid());
			detail.setOrgid(StringUtils.isNotEmpty(scriptWithOptions.getOrgid()) ? scriptWithOptions.getOrgid()
			: (serviceTask != null ? serviceTask.getOrgid() : null));
			detail.setCreateTime(new Date());
			detail.setUpdateTime(new Date());

			if (existing != null) {
			detail.setId(existing.getId());
			serviceSubtaskDetailMapper.updateServiceSubtaskDetail(detail);
			} else {
			serviceSubtaskDetailMapper.insertServiceSubtaskDetail(detail);
			}
			filled++;
			}
			return filled;
			}

			@Override
			public Map<String, Object> getHeLibraryCount(@RequestBody HeLibraryCountVO heLibraryCountVO) {
			if (ObjectUtils.isEmpty(heLibraryCountVO)) {
			@@ -3972,12 +5134,6 @@
			String subId = rsaPublicKeyExample.encryptedData(serviceSubtask.getId().toString(), pub_key);
			String taskId = rsaPublicKeyExample.encryptedData(serviceSubtask.getTaskid().toString(), pub_key);

			//丽水中医院发送的是微信公众号
			if (StringUtils.isNotEmpty(serviceSubtask.getOrgid()) && serviceSubtask.getOrgid().equals("47231022633110211A2101")) {
			resultMap = wechatSubTask(subid);
			return resultMap;
			}

			//发送数据的封装
			ServiceOutPath serviceOutPath = new ServiceOutPath();
			serviceOutPath.setParam1(taskId);
			@@ -3987,7 +5143,7 @@
			serviceOutPath.setCreateTime(new Date());
			serviceOutPath.setOrgid(serviceSubtask.getOrgid());
			iServiceOutPathService.insertServiceOutPath(serviceOutPath);
			String format = String.format("%03X", serviceOutPath.getId());
			String format = ShortCode.encode(serviceOutPath.getId());
			String url = "";
			SendMagParam sendMagParam = new SendMagParam();
			sendMagParam.setType("4");
			@@ -4025,6 +5181,25 @@
			return resultMap;
			}

			@Override
			public Map<String, Object> weChatSubTask(Long subid) {
			log.info("smsSubTask的入参为：{}", subid);
			Map<String, Object> resultMap = new HashMap<>();
			resultMap.put("code", "500");
			resultMap.put("msg", "发送失败");

			//获取患者的基本信息
			ServiceSubtask serviceSubtask = selectServiceSubtaskById(subid);
			RSAPublicKeyExample rsaPublicKeyExample = new RSAPublicKeyExample();
			String patid = rsaPublicKeyExample.encryptedData(serviceSubtask.getPatid().toString(), pub_key);
			String subId = rsaPublicKeyExample.encryptedData(serviceSubtask.getId().toString(), pub_key);
			String taskId = rsaPublicKeyExample.encryptedData(serviceSubtask.getTaskid().toString(), pub_key);

			//丽水中医院发送的是微信公众号
			resultMap = wechatSubTask(subid);
			return resultMap;
			}

			public Map<String,Object> wechatSubTask(Long subid){
			log.info("wechatSubTask的入参为：{}", subid);
			Map<String, Object> resultMap = new HashMap<>();
			@@ -4052,14 +5227,22 @@
			serviceOutPath.setCreateTime(new Date());
			serviceOutPath.setOrgid(serviceSubtask.getOrgid());
			iServiceOutPathService.insertServiceOutPath(serviceOutPath);
			String format = String.format("%03X", serviceOutPath.getId());
			String format = ShortCode.encode(serviceOutPath.getId());
			serviceOutPath.setRadix(format);
			serviceOutPath.setUpdateTime(new Date());
			serviceOutPath.setUrl(url);
			iServiceOutPathService.updateServiceOutPath(serviceOutPath);

			//his患者id校验（与原实现一致：先校验这一项）
			if (StringUtils.isEmpty(serviceSubtask.getPatidHis())) {

			if (patArchive == null) {
			resultMap.put("code", -1);
			resultMap.put("message", "发送异常：" + "【公众号】未查询到患者档案信息，无法通过公众号发送");
			return resultMap;
			}

			// his系统的患者id取自患者档案pat_archive.patid_his，
			// service_subtask查询未关联该字段（serviceSubtask.getPatidHis()恒为空），不能用于校验
			if (StringUtils.isEmpty(patArchive.getPatidHis())) {
			resultMap.put("code", -1);
			resultMap.put("message", "发送异常：" + "【公众号】公众号发送失败,his系统的患者id为空");
			return resultMap;
			@@ -4259,7 +5442,7 @@
			serviceOutPath.setCreateTime(new Date());
			serviceOutPath.setOrgid(serviceTask.getOrgid());
			iServiceOutPathService.insertServiceOutPath(serviceOutPath);
			String format = String.format("%03X", serviceOutPath.getId());
			String format = ShortCode.encode(serviceOutPath.getId());
			serviceOutPath.setRadix(format);
			serviceOutPath.setUpdateTime(new Date());
			String url = StringUtils.isNotEmpty(req_path) ? ip + ":" + req_path + "/wt?p=" + format : ip + "/wt?p=" + format;