liusheng
13 小时以前 e180e3a496d6f29d3a3b34016400de9d997c6bd9
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
package com.smartor.service.impl;
 
import java.util.*;
import java.util.stream.Collectors;
 
import com.github.pagehelper.util.StringUtil;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.smartor.domain.*;
import com.smartor.domain.DTO.DetailTraceDealDTO;
import com.smartor.domain.VO.DetailTraceDealVO;
import com.smartor.domain.VO.SatisfactionExceptConfigQuestionReqVO;
import com.smartor.mapper.ServiceSubtaskDetailMapper;
import com.smartor.mapper.ServiceSubtaskDetailTraceMapper;
import com.smartor.mapper.SvyLibScriptCategoryMapper;
import com.smartor.mapper.SvyLibTemplateScriptMapper;
import com.smartor.service.*;
import org.apache.commons.collections4.CollectionUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
/**
 * 随访任务异常记录跟踪Service业务层处理
 *
 * @author lihu
 * @date 2026-03-24
 */
@Service
public class ServiceSubtaskDetailTraceServiceImpl implements IServiceSubtaskDetailTraceService {
    @Autowired
    private ServiceSubtaskDetailTraceMapper serviceSubtaskDetailTraceMapper;
 
    @Autowired
    private ServiceSubtaskDetailMapper serviceSubtaskDetailMapper;
 
    @Autowired
    private ISvyLibScriptCategoryService iSvyLibScriptCategoryService;
 
    @Autowired
    private SvyLibScriptCategoryMapper svyLibScriptCategoryMapper;
 
    @Autowired
    private ISvyLibTemplateScriptService isvyLibTemplateScriptService;
 
    @Autowired
    private IIvrLibaScriptAssortService iIvrLibaScriptAssortService;
 
    @Autowired
    private IIvrLibaTemplateScriptService iIvrLibaTemplateScriptService;
 
    /**
     * 查询随访任务异常记录跟踪
     *
     * @param id 随访任务异常记录跟踪主键
     * @return 随访任务异常记录跟踪
     */
    @Override
    public ServiceSubtaskDetailTrace selectServiceSubtaskDetailTtraceById(Long id) {
        return serviceSubtaskDetailTraceMapper.selectServiceSubtaskDetailTtraceById(id);
    }
 
    /**
     * 查询随访任务异常记录跟踪列表
     *
     * @param serviceSubtaskDetailTrace 随访任务异常记录跟踪
     * @return 随访任务异常记录跟踪
     */
    @Override
    public List<ServiceSubtaskDetailTrace> selectServiceSubtaskDetailTtraceList(ServiceSubtaskDetailTrace serviceSubtaskDetailTrace) {
        return serviceSubtaskDetailTraceMapper.selectServiceSubtaskDetailTtraceList(serviceSubtaskDetailTrace);
    }
 
    @Override
    public List<DetailTraceDealDTO> tracedeallist(DetailTraceDealVO detailTraceDealVO) {
        // 获取所有需要处理的记录
        List<ServiceSubtaskDetailTrace> tracedeallist = serviceSubtaskDetailTraceMapper.tracedeallist(detailTraceDealVO);
 
        // 按 questiontext 分组
        Map<String, List<ServiceSubtaskDetailTrace>> groupByQuestion = tracedeallist.stream()
                .filter(t -> t.getQuestiontext() != null)
                .collect(Collectors.groupingBy(ServiceSubtaskDetailTrace::getQuestiontext));
 
        List<DetailTraceDealDTO> detailTraceDealDTOList = new ArrayList<>();
        for (Map.Entry<String, List<ServiceSubtaskDetailTrace>> entry : groupByQuestion.entrySet()) {
            List<ServiceSubtaskDetailTrace> group = entry.getValue();
            DetailTraceDealDTO dto = new DetailTraceDealDTO();
 
            // 问题内容
            dto.setQuestiontext(entry.getKey());
 
            // 负责科室(去重)
            List<Map<String, Object>> responsibleDept = group.stream()
                    .filter(t -> t.getTodeptcode() != null)
                    .collect(Collectors.collectingAndThen(
                            Collectors.toMap(
                                    ServiceSubtaskDetailTrace::getTodeptcode,
                                    t -> {
                                        Map<String, Object> deptMap = new HashMap<>();
                                        deptMap.put("deptName", t.getTodeptname());
                                        deptMap.put("deptCode", t.getTodeptcode());
                                        return deptMap;
                                    },
                                    (existing, replacement) -> existing
                            ),
                            map -> new ArrayList<>(map.values())
                    ));
            dto.setResponsibleDept(responsibleDept);
 
            // 有效填写数:通过组内的 scriptid 去 service_subtask_detail 表查询
            List<Long> scriptIds = group.stream()
                    .map(ServiceSubtaskDetailTrace::getScriptid)
                    .filter(Objects::nonNull)
                    .distinct()
                    .collect(Collectors.toList());
            long effectiveFillNum = 0L;
            if (CollectionUtils.isNotEmpty(scriptIds)) {
                ServiceSubtaskDetail query = new ServiceSubtaskDetail();
                query.setDelFlag("0");
                for (Long scriptId : scriptIds) {
                    query.setScriptid(scriptId);
                    List<ServiceSubtaskDetail> details = serviceSubtaskDetailMapper.selectServiceSubtaskDetailList(query);
                    effectiveFillNum += CollectionUtils.isEmpty(details) ? 0 : details.size();
                }
            }
 
            // 异常填写数 = 当前分组的 List 数量
            long exceptionFillNum = group.size();
 
            Map<String, Object> fillSituation = new HashMap<>();
            fillSituation.put("effectiveFillNum", effectiveFillNum);
            fillSituation.put("exceptionFillNum", exceptionFillNum);
            dto.setFillSituation(fillSituation);
 
            // 异常问题处理数量:从 handleFlag 统计
            long yesDeal = group.stream().filter(t -> "1".equals(t.getHandleFlag())).count();
            long noDeal = group.stream().filter(t -> !"1".equals(t.getHandleFlag())).count();
            Map<String, Object> exceptionQuesNum = new HashMap<>();
            exceptionQuesNum.put("yesDeal", yesDeal);
            exceptionQuesNum.put("noDeal", noDeal);
            exceptionQuesNum.put("all", exceptionFillNum);
            dto.setExceptionQuesNum(exceptionQuesNum);
 
            // 最新处理人和处理时间(取 handleTime 最新的一条)
            group.stream()
                    .filter(t -> t.getHandleTime() != null)
                    .max(Comparator.comparing(ServiceSubtaskDetailTrace::getHandleTime))
                    .ifPresent(latest -> {
                        dto.setHandleBy(latest.getHandleBy());
                        dto.setHandleTime(latest.getHandleTime());
                    });
 
            detailTraceDealDTOList.add(dto);
        }
 
        return detailTraceDealDTOList;
    }
 
    /**
     * 新增随访任务异常记录跟踪
     *
     * @param serviceSubtaskDetailTrace 随访任务异常记录跟踪
     * @return 结果
     */
    @Override
    public int insertServiceSubtaskDetailTtrace(ServiceSubtaskDetailTrace serviceSubtaskDetailTrace) {
        serviceSubtaskDetailTrace.setCreateTime(DateUtils.getNowDate());
        return serviceSubtaskDetailTraceMapper.insertServiceSubtaskDetailTtrace(serviceSubtaskDetailTrace);
    }
 
    /**
     * 修改随访任务异常记录跟踪
     *
     * @param serviceSubtaskDetailTrace 随访任务异常记录跟踪
     * @return 结果
     */
    @Override
    public int updateServiceSubtaskDetailTtrace(ServiceSubtaskDetailTrace serviceSubtaskDetailTrace) {
        serviceSubtaskDetailTrace.setUpdateTime(DateUtils.getNowDate());
        return serviceSubtaskDetailTraceMapper.updateServiceSubtaskDetailTtrace(serviceSubtaskDetailTrace);
    }
 
    /**
     * 批量删除随访任务异常记录跟踪
     *
     * @param ids 需要删除的随访任务异常记录跟踪主键
     * @return 结果
     */
    @Override
    public int deleteServiceSubtaskDetailTtraceByIds(Long[] ids) {
        return serviceSubtaskDetailTraceMapper.deleteServiceSubtaskDetailTtraceByIds(ids);
    }
 
    /**
     * 删除随访任务异常记录跟踪信息
     *
     * @param id 随访任务异常记录跟踪主键
     * @return 结果
     */
    @Override
    public int deleteServiceSubtaskDetailTtraceById(Long id) {
        return serviceSubtaskDetailTraceMapper.deleteServiceSubtaskDetailTtraceById(id);
    }
 
    @Override
    public Map<String, Object> getSatisfactionExceptConfigQuestion(SatisfactionExceptConfigQuestionReqVO questionReqVO) {
        // 初始化结果集
        Map<String, Object> result = new HashMap<>();
 
        if (StringUtils.isEmpty(questionReqVO.getScriptType()) || questionReqVO.getScriptType().equals("1")) {
            List<Map<String, Object>> voicetDataList = new ArrayList<>();
            //获取满意度的分类
            IvrLibaScriptAssort ivrLibaScriptAssort = new IvrLibaScriptAssort();
            ivrLibaScriptAssort.setType("myd");
            if (!StringUtils.isEmpty(questionReqVO.getType())) ivrLibaScriptAssort.setType(questionReqVO.getType());
            List<IvrLibaScriptAssortVO> ivrLibaScriptAssortVOS = iIvrLibaScriptAssortService.selectIvrLibaScriptAssortList(ivrLibaScriptAssort);
            List<Long> assortIdList = Optional.ofNullable(ivrLibaScriptAssortVOS).filter(list -> !list.isEmpty()).map(list -> list.stream().map(IvrLibaScriptAssortVO::getId).collect(Collectors.toList())).orElse(Collections.emptyList());
 
            //用来记录满意度的所有问题
            List<IvrLibaTemplateScript> ivrLibaTemplateScriptList = new ArrayList<>();
            if (CollectionUtils.isNotEmpty(assortIdList)) {
                for (Long assortId : assortIdList) {
                    IvrLibaTemplateScript ivrLibaTemplateScript = new IvrLibaTemplateScript();
                    ivrLibaTemplateScript.setScriptAssortid(assortId);
                    List<IvrLibaTemplateScript> ivrLibaTemplateScripts = iIvrLibaTemplateScriptService.selectIvrLibaTemplateScriptList(ivrLibaTemplateScript);
                    ivrLibaTemplateScriptList.addAll(ivrLibaTemplateScripts);
                }
                for (IvrLibaTemplateScript ivrLibaTemplateScript : ivrLibaTemplateScriptList) {
                    Map<String, Object> voicetData = new HashMap<>();
                    voicetData.put("questionId", ivrLibaTemplateScript.getId());
                    voicetData.put("libtemplateid", ivrLibaTemplateScript.getTemplateid());
                    voicetData.put("questionContent", ivrLibaTemplateScript.getScriptContent());
                    voicetData.put("questionTopic", ivrLibaTemplateScript.getScriptTopic());
                    voicetData.put("questionType", ivrLibaTemplateScript.getScriptType());
                    voicetData.put("categoryName", ivrLibaTemplateScript.getScriptAssortname());
                    voicetData.put("categoryId", ivrLibaTemplateScript.getScriptAssortid());
                    voicetDataList.add(voicetData);
                }
            }
            //语音数据返回集合
            result.put("voiceDataList", voicetDataList);
        }
 
        if (StringUtils.isEmpty(questionReqVO.getScriptType()) || questionReqVO.getScriptType().equals("2")) {
            List<Map<String, Object>> questionnaireDataList = new ArrayList<>();
            //获取满意度的分类
            SvyLibScriptCategory svyLibScriptCategory = new SvyLibScriptCategory();
            svyLibScriptCategory.setType("myd");
            if (!StringUtils.isEmpty(questionReqVO.getType())) svyLibScriptCategory.setType(questionReqVO.getType());
            List<SvyLibScriptCategory> svyLibScriptCategoryVOS = svyLibScriptCategoryMapper.selectSvyLibScriptCategoryList(svyLibScriptCategory);
            List<Long> assortIdList = Optional.ofNullable(svyLibScriptCategoryVOS).filter(list -> !list.isEmpty()).map(list -> list.stream().map(SvyLibScriptCategory::getId).collect(Collectors.toList())).orElse(Collections.emptyList());
 
            //用来记录满意度的所有问题
            List<SvyLibTemplateScript> svyLibTemplateScriptList = new ArrayList<>();
            if (CollectionUtils.isNotEmpty(assortIdList)) {
                for (Long categoryid : assortIdList) {
                    SvyLibTemplateScript svyLibTemplateScript = new SvyLibTemplateScript();
                    svyLibTemplateScript.setCategoryid(categoryid);
                    List<SvyLibTemplateScript> svyLibTemplateScripts = isvyLibTemplateScriptService.selectSvyLibTemplateScriptList(svyLibTemplateScript);
                    svyLibTemplateScriptList.addAll(svyLibTemplateScripts);
                }
                for (SvyLibTemplateScript svyLibTemplateScript : svyLibTemplateScriptList) {
                    Map<String, Object> voicetData = new HashMap<>();
                    voicetData.put("questionId", svyLibTemplateScript.getId());
                    voicetData.put("libtemplateid", svyLibTemplateScript.getSvyid());
                    voicetData.put("questionContent", svyLibTemplateScript.getScriptContent());
                    voicetData.put("questionTopic", svyLibTemplateScript.getScriptTopic());
                    voicetData.put("questionType", svyLibTemplateScript.getScriptType());
                    voicetData.put("categoryName", svyLibTemplateScript.getCategoryName());
                    voicetData.put("categoryId", svyLibTemplateScript.getCategoryid());
                    questionnaireDataList.add(voicetData);
                }
            }
            //问卷数据返回集合
            result.put("questionnaireDataList", questionnaireDataList);
        }
        return result;
    }
}