list = satisfactionMapper.selectMzMydScoreRank(mzMydScoreRankVO);
if (CollectionUtils.isEmpty(list)) {
return new ArrayList<>();
}
// 名次：SQL 已按综合得分降序返回，这里顺序编号
for (int i = 0; i < list.size(); i++) {
list.get(i).setRank(i + 1);
}
return list;
}
/**
* 是否空白字符（含全角空格）。
*
* 迁移说明：原为 ServiceSubtaskServiceImpl 的私有静态方法，满意度方法用到（trimAll），一并搬入。
*/
private static Boolean isBlankChar(char c) {
return c == '\u3000' // 全角空格
|| c == ' ' // 半角空格
|| c == '\t' || c == '\n' || c == '\r' || c == '\f' || Character.isWhitespace(c);
}
/**
* 按机构/院区/服务类型/出院时间/科室病区取子任务引用（只含 id、taskid）。
*
* 原实现走 {@code serviceSubtaskService.getServiceSubtasks(ServiceSubtaskEntity)}，
* 该方法位于随访主干 Service 且依赖 patArchiveService，不能搬；
* 这里用满意度专用查询复现其实际用到的条件口径（逐条见 mapper XML 注释）。
*/
@Override
public List getMydSubtaskRefs(SatisfactionSubtaskQuery query) {
if (query == null) {
return new ArrayList<>();
}
List refs = satisfactionMapper.selectMydSubtaskRefs(query);
return refs == null ? new ArrayList<>() : refs;
}
// ==================== 满意度分类（供登录链路，带缓存） ====================
/**
* 满意度分类缓存 key 前缀（与迁移前一致）
*/
private static final String SATISFACTION_CACHE_KEY = "satisfaction:categories:";
/**
* 满意度分类缓存时长（分钟，与迁移前一致）
*/
private static final int SATISFACTION_CACHE_TTL = 30;
@Autowired
private RedisCache redisCache;
/**
* 获取满意度问题分类（语音 + 问卷），带 Redis 缓存。
*
* 迁移说明：原为 {@code smartor.UserExtInfoServiceImpl.getSatisfactionCategories}，
* 因属于满意度逻辑，按模块化要求搬入本模块；缓存 key 与 TTL 保持原值。
*/
@Override
@SuppressWarnings("unchecked")
public Map getSatisfactionCategories(String orgid) {
// 先查缓存
String cacheKey = SATISFACTION_CACHE_KEY + orgid;
Map cached = redisCache.getCacheObject(cacheKey);
if (cached != null) {
return cached;
}
Map satisfactionCategories = new HashMap<>();
// 获取语音问题分类
List ivrLibaScriptAssorts =
satisfactionScriptMapper.selectIvrCategoryList(categoryQueryByOrgid(orgid));
List> categoryList = new ArrayList<>();
if (!CollectionUtils.isEmpty(ivrLibaScriptAssorts)) {
for (SatisfactionCategoryRow assort : ivrLibaScriptAssorts) {
Map map = new HashMap<>();
map.put("categoryid", assort.getId());
map.put("categoryName", assort.getName());
categoryList.add(map);
}
}
satisfactionCategories.put("voiceCategories", categoryList);
// 获取问卷问题分类
List svyLibScriptCategories =
satisfactionScriptMapper.selectSvyCategoryList(categoryQueryByOrgid(orgid));
List> questionnaireCategorys = new ArrayList<>();
if (!CollectionUtils.isEmpty(svyLibScriptCategories)) {
for (SatisfactionCategoryRow scriptCategory : svyLibScriptCategories) {
Map map = new HashMap<>();
map.put("categoryid", scriptCategory.getId());
map.put("categoryName", scriptCategory.getName());
questionnaireCategorys.add(map);
}
}
satisfactionCategorysPut(satisfactionCategories, questionnaireCategorys);
// 写入缓存
redisCache.setCacheObject(cacheKey, satisfactionCategories, SATISFACTION_CACHE_TTL, TimeUnit.MINUTES);
return satisfactionCategories;
}
/**
* 与原文一致：键名为 {@code questionnaireCategorys}
*/
private void satisfactionCategorysPut(Map target, List> value) {
target.put("questionnaireCategorys", value);
}
/**
* 按机构构造满意度分类查询（orgid + type=myd，与原文一致）
*/
private SatisfactionScriptQuery categoryQueryByOrgid(String orgid) {
SatisfactionScriptQuery q = new SatisfactionScriptQuery();
q.setOrgid(orgid);
q.setType("myd");
return q;
}
// ==================== 满意度异常配置题目 ====================
/**
* 获取满意度异常配置题目（语音 + 问卷）。
*
* 迁移说明：原实现位于 {@code com.smartor.service.impl.ServiceSubtaskDetailTraceServiceImpl}，
* 现整段搬入本模块。原来的调用链是：
*
* 语音分类：IvrLibaScriptAssortServiceImpl.selectIvrLibaScriptAssortList ← 服务方法，会把分类【拼成树】，只返回顶层
* 语音题目：IvrLibaTemplateScriptServiceImpl.selectIvrLibaTemplateScriptList(scriptAssortid=X) ← 逐个分类调用
* 问卷分类：SvyLibScriptCategoryMapper.selectSvyLibScriptCategoryList ← 直接 Mapper，返回【全部】分类
* 问卷题目：SvyLibTemplateScriptServiceImpl.selectSvyLibTemplateScriptList(categoryid=Y) ← 逐个分类调用
*
* 为不依赖 smartor 的模板/分类实体，这里改成本模块的只读查询复现，并且：
*
* - 语音分类：仍然按顶层过滤（{@code pid == null || pid == -1}），与原服务方法的结果集一致；
* - 问卷分类：不过滤顶层，取全部，与原 Mapper 调用一致；
* - 题目：原文是按分类逐个查询后累加，两条 list statement 都没有 order by，
* 所以合并成一次 {@code in (...)} 查询的结果集与逐次查询的并集一致
* （集合相同、顺序本来就未定义）；
* - 分类 id 列表为空时不查（原文就是在 {@code if (isNotEmpty)} 里才查），
* 对应本模块 SQL 里"ids 为空则不拼 in 条件"的写法必须靠这个判断兜住，
* 否则会退化成"全表查询"。
*
*/
@Override
public Map getSatisfactionExceptConfigQuestion(SatisfactionExceptConfigQuestionReqVO questionReqVO) {
// 初始化结果集
Map result = new HashMap<>();
// ---------------------------------------------------------------- 语音
if (StringUtils.isEmpty(questionReqVO.getScriptType()) || questionReqVO.getScriptType().equals("1")) {
List> voicetDataList = new ArrayList<>();
// 获取满意度的分类（type 默认 myd，入参有值则覆盖 —— 与原文一致）
List assortIdList = selectIvrTopCategoryIds(questionReqVO.getType());
// 用来记录满意度的所有问题
if (CollectionUtils.isNotEmpty(assortIdList)) {
SatisfactionScriptQuery scriptQuery = new SatisfactionScriptQuery();
scriptQuery.setScriptAssortids(assortIdList);
List ivrScripts =
satisfactionScriptMapper.queryIvrScriptByAssort(scriptQuery);
if (CollectionUtils.isNotEmpty(ivrScripts)) {
for (SatisfactionIvrScriptRow ivrScript : ivrScripts) {
Map voicetData = new HashMap<>();
voicetData.put("questionId", ivrScript.getId());
voicetData.put("libtemplateid", ivrScript.getTemplateid());
voicetData.put("questionContent", ivrScript.getScriptContent());
voicetData.put("questionTopic", ivrScript.getScriptTopic());
voicetData.put("questionType", ivrScript.getScriptType());
voicetData.put("categoryName", ivrScript.getScriptAssortname());
voicetData.put("categoryId", ivrScript.getScriptAssortid());
voicetDataList.add(voicetData);
}
}
}
// 语音数据返回集合
result.put("voiceDataList", voicetDataList);
}
// ---------------------------------------------------------------- 问卷
if (StringUtils.isEmpty(questionReqVO.getScriptType()) || questionReqVO.getScriptType().equals("2")) {
List> questionnaireDataList = new ArrayList<>();
// 获取满意度的分类（问卷侧原文直接查 Mapper，取全部分类，不拼树、不筛顶层）
List categoryIdList = selectSvyCategoryIds(questionReqVO.getType());
// 用来记录满意度的所有问题
if (CollectionUtils.isNotEmpty(categoryIdList)) {
SatisfactionScriptQuery scriptQuery = new SatisfactionScriptQuery();
scriptQuery.setScriptCategoryids(categoryIdList);
List svyScripts =
satisfactionScriptMapper.querySvyScriptByCategory(scriptQuery);
if (CollectionUtils.isNotEmpty(svyScripts)) {
for (SatisfactionSvyScriptRow svyScript : svyScripts) {
Map svyData = new HashMap<>();
svyData.put("questionId", svyScript.getId());
svyData.put("libtemplateid", svyScript.getSvyid());
svyData.put("questionContent", svyScript.getScriptContent());
svyData.put("questionTopic", svyScript.getScriptTopic());
svyData.put("questionType", svyScript.getScriptType());
svyData.put("categoryName", svyScript.getCategoryName());
svyData.put("categoryId", svyScript.getCategoryid());
questionnaireDataList.add(svyData);
}
}
}
// 问卷数据返回集合
result.put("questionnaireDataList", questionnaireDataList);
}
return result;
}
/**
* 取语音侧满意度分类 id（只取顶层，复现原服务方法拼树后的返回值）。
*
* @param type 满意度类型；为空时用 {@code "myd"}
*/
private List selectIvrTopCategoryIds(String type) {
SatisfactionScriptQuery query = new SatisfactionScriptQuery();
query.setType(StringUtils.isEmpty(type) ? "myd" : type);
// 原文没有传 orgid，这里保持一致（orgid 为空时 SQL 不拼该条件）
List rows = satisfactionScriptMapper.selectIvrCategoryList(query);
List ids = new ArrayList<>();
if (CollectionUtils.isNotEmpty(rows)) {
for (SatisfactionCategoryRow row : rows) {
// 与 IvrLibaScriptAssortServiceImpl 拼树时的顶层判断逐字一致
if (row.getPid() == null || row.getPid() == -1) {
ids.add(row.getId());
}
}
}
return ids;
}
/**
* 取问卷侧满意度分类 id（取全部，复现原 Mapper 调用的返回值）。
*
* @param type 满意度类型；为空时用 {@code "myd"}
*/
private List selectSvyCategoryIds(String type) {
SatisfactionScriptQuery query = new SatisfactionScriptQuery();
query.setType(StringUtils.isEmpty(type) ? "myd" : type);
List rows = satisfactionScriptMapper.selectSvyCategoryList(query);
List ids = new ArrayList<>();
if (CollectionUtils.isNotEmpty(rows)) {
for (SatisfactionCategoryRow row : rows) {
ids.add(row.getId());
}
}
return ids;
}
// ==================== 随访「满意度指数」 ====================
/**
* 「满意度题目发送量」统计时使用的子任务发送状态（与原实现一致：3、5、6）
*/
private static final List SATISFACTION_INDEX_SENDSTATES =
Collections.unmodifiableList(Arrays.asList(3L, 5L, 6L));
/**
* 随访统计页的「满意度指数」：满意度题目总量 / 填报量 / 完成比例。
*
* 迁移说明：原为 {@code com.smartor.service.impl.ServiceSubtaskServiceImpl#getSatisfactionIndex}
* 的私有方法，被 {@code getSfStatisticsJoy} 调用。它的取数对象是
* 「满意度题目」（按 {@code ivrCategoryid} / {@code svyCategoryid} 识别）与
* 「满意度填报明细」，属于满意度口径，故搬入本模块。
*
* 与原实现逐条对应：
*
* - {@code type="1"} 用 {@code deptcode} 匹配任务；{@code type="2"} 用
* {@code leavehospitaldistrictcode} 匹配任务（互斥，都带 orgid）；
* - 语音任务：题目数 = 该模板下 {@code script_assortid = ivrCategoryid} 的题目数；
* 总量 += 题目数 × 发送量（{@code sendstate in (3,5,6)}）；
* - 问卷任务：同上，用 {@code categoryid = svyCategoryid}；
* - 填报量：按 {@code taskid + categoryid(按任务类型取语音/问卷) + orgid} 数明细条数；
* - 完成比例 = 填报量 / 总量（保留 2 位，HALF_UP），总量为 0 时为 {@code 0.0}。
*
*
* ⚠️ 原实现已知缺陷（本次原样保留，未修复）
* 原代码用的是 {@code mydtmzlsum.add(new BigDecimal(n))} ——
* {@link BigDecimal} 是不可变类，{@code add} 的返回值没有被赋回变量，
* 因此所有累加都是无效的，本方法实际上恒定返回
* {@code {mydtmzl: 0, mydtbl: 0, wcbl: 0.0}}；
* 同时因为累加语句仍在循环里，每次调用依旧会真实执行那 5 条查询。
*
* 迁移时按"行为不变"原则一字未改（连无效累加也保留）：
* 若直接把查询结果改成常量，虽然返回值相同，但会改变数据库压力；
* 若把 {@code add} 改成 {@code xxx = xxx.add(...)}，则会改变随访统计页的显示值。
* 两种都超出本次"模块化、不改行为"的范围，故留待单独确认。
* 详见 {@code doc/满意度模块化_执行进度.md} 的遗留项。
*
* @param type "1"=按科室，"2"=按病区（与原文一致）
* @param code 科室编码或病区编码
* @param orgid 机构 id
* @param ivrCategoryid 语音满意度分类 id（可为 null，为 null 时该条件不生效）
* @param svyCategoryid 问卷满意度分类 id（可为 null，为 null 时该条件不生效）
* @return 含 {@code mydtmzl}(Integer) / {@code mydtbl}(Integer) / {@code wcbl}(Double) 的 Map
*/
@Override
public Map getSatisfactionIndex(String type, String code, String orgid,
Long ivrCategoryid, Long svyCategoryid) {
// 原文是 type.equals("1")；调用方只传字面量 "1"/"2"，这里用常量在前等价且更安全
List serviceTasks = null;
if ("1".equals(type)) {
serviceTasks = satisfactionMapper.selectSatisfactionServiceTasks(orgid, code, null);
} else if ("2".equals(type)) {
serviceTasks = satisfactionMapper.selectSatisfactionServiceTasks(orgid, null, code);
}
// 获取满意度题目总量
BigDecimal mydtmzlsum = new BigDecimal(0);
// 获取满意度题目填报量
BigDecimal mydtblsum = new BigDecimal(0);
if (CollectionUtils.isNotEmpty(serviceTasks)) {
for (SatisfactionTaskRow serviceTask : serviceTasks) {
if (serviceTask.getType().equals("1")) {
// 语音
Long templateid = serviceTask.getTemplateid();
int scriptCount = satisfactionMapper.countIvrTaskTemplateScripts(
templateid, serviceTask.getOrgid(), ivrCategoryid);
if (scriptCount > 0) {
// 需要先计算出发送量，再乘以单个问券满意度题目数量，得到满意度题目总量（包含了未做的）
int subtaskCount = satisfactionMapper.countSubtaskBySendstates(
serviceTask.getTaskid(), SATISFACTION_INDEX_SENDSTATES);
if (subtaskCount > 0) {
int mydtmzlCount = scriptCount * subtaskCount;
// ⚠️ 原实现缺陷：add 的返回值被丢弃（BigDecimal 不可变），此处原样保留
mydtmzlsum.add(new BigDecimal(mydtmzlCount));
}
}
} else if (serviceTask.getType().equals("2")) {
// 问卷
int scriptCount = satisfactionMapper.countSvyTaskTemplateScripts(
serviceTask.getTemplateid(), serviceTask.getOrgid(), svyCategoryid);
if (scriptCount > 0) {
int subtaskCount = satisfactionMapper.countSubtaskBySendstates(
serviceTask.getTaskid(), SATISFACTION_INDEX_SENDSTATES);
if (subtaskCount > 0) {
int mydtmzlCount = scriptCount * subtaskCount;
// ⚠️ 原实现缺陷：同上，原样保留
mydtmzlsum.add(new BigDecimal(mydtmzlCount));
}
}
}
// 获取满意度题目填报量
Long categoryid = null;
if (serviceTask.getType().equals("1")) categoryid = ivrCategoryid;
if (serviceTask.getType().equals("2")) categoryid = svyCategoryid;
int detailCount = satisfactionMapper.countSubtaskDetail(
serviceTask.getTaskid(), categoryid, serviceTask.getOrgid());
if (detailCount > 0) {
// ⚠️ 原实现缺陷：同上，原样保留
mydtblsum.add(new BigDecimal(detailCount));
}
}
}
Map map = new HashMap<>();
// 满意度题目总量
map.put("mydtmzl", mydtmzlsum.intValue());
map.put("mydtbl", mydtblsum.intValue());
map.put("wcbl", 0.0);
if (mydtmzlsum.intValue() != 0) {
map.put("wcbl", mydtblsum.divide(mydtmzlsum, 2, RoundingMode.HALF_UP).doubleValue());
}
return map;
}
}