双重预防项目-国泰新华二开定制版
heheng
2 天以前 ac8870aae3ec2b5ec5315cc668b482858195cfa4
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
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
package com.ruoyi.project.mobile.service;
 
 
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.pagehelper.util.StringUtil;
import com.ruoyi.common.constant.TrHiddenDangerCheckConstants;
import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.common.utils.StringUtils;
import com.ruoyi.common.utils.security.ShiroUtils;
import com.ruoyi.doublePrevention.entity.PreventRiskDangerCheckAndMeasure;
import com.ruoyi.doublePrevention.entity.PreventRiskDangerCheckLog;
import com.ruoyi.doublePrevention.entity.PreventRiskDangerInfo;
import com.ruoyi.doublePrevention.service.RiskService;
import com.ruoyi.doublePrevention.service.baseService.PreventRiskDangerCheckAndMeasureService;
import com.ruoyi.framework.web.domain.AjaxResult;
import com.ruoyi.project.mobile.domain.ApiRequestHeader;
import com.ruoyi.project.mobile.domain.ApiResult;
import com.ruoyi.project.system.user.domain.User;
import com.ruoyi.project.system.user.service.IUserService;
import com.ruoyi.project.tr.hiddenDangerCheck.domain.HiddenDangerCheck;
import com.ruoyi.project.tr.hiddenDangerCheck.service.IHiddenDangerCheckService;
import com.ruoyi.project.tr.hiddenDangerCheckPoint.domain.HiddenDangerCheckPoint;
import com.ruoyi.project.tr.hiddenDangerCheckPoint.service.IHiddenDangerCheckPointService;
import org.apache.commons.lang3.ObjectUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
 
 
@Service
public class ApiDangerScheduleService extends BaseApiService {
 
    private static Logger logger = LoggerFactory.getLogger(ApiDangerScheduleService.class);
 
    @Autowired
    IHiddenDangerCheckService hiddenDangerCheckService;//隐患Service
 
    @Autowired
    IHiddenDangerCheckPointService hdcpService;//隐患检查点Service
 
    @Autowired
    IUserService userService;//用户Service
 
    @Autowired
    private RiskService riskService;
 
    @Autowired
    private PreventRiskDangerCheckAndMeasureService riskDangerCheckAndMeasureService;//隐患检查点Service
 
    @Autowired
    private PreventRiskDangerCheckAndMeasureService preventRiskDangerCheckAndMeasureService;
    /**
     * 获取定时任务隐患列表
     *
     * @param str
     * @param header
     * @return
     */
    public ApiResult getDangerScheduleList(String str, ApiRequestHeader header) {
        //验证userId,loginName,token,deviceType,deviceId,appType 是否一致
        ApiRequestHeader requestHeader = getHeader(header);
        if (!(header.equals(requestHeader))) {
            return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
        }
 
        String loginName = header.loginName;
        try {
            Map<String, String> queryHiddenDangerCheck = new ObjectMapper().readValue(str, HashMap.class);
            String hiddenDangerCheckType = queryHiddenDangerCheck.get("hiddenDangerCheckType");//隐患类型
            String hiddenDangerCheckStatus = queryHiddenDangerCheck.get("hiddenDangerCheckStatus");//隐患状态
            HiddenDangerCheck hiddenDangerCheck = new HiddenDangerCheck();
 
            if (StringUtils.isEmpty(hiddenDangerCheckType) || StringUtils.isEmpty(hiddenDangerCheckType)) {
                return ApiResult.error("传输hiddenDangerCheckType为空");
            } else {
                if ("schedule".equals(hiddenDangerCheckType)) {
                    hiddenDangerCheck.setScheduleCheckUserId(Long.valueOf(header.userId));//定时任务排查执行人
                    hiddenDangerCheck.setScheduleCheckStatus(hiddenDangerCheckStatus);//定时任务排查状态
 
                }  else {
                    return ApiResult.error("传输hiddenDangerCheckType有误");
                }
                List<HiddenDangerCheck> resultList = hiddenDangerCheckService.selectHiddenDangerCheckList(hiddenDangerCheck);
//                //特殊处理(  增加清单文件(basicListFileUrl)为在线预览url,其前缀为http://view.xdocin.com/xdoc?_xdoc=  )
//                String xdocinUrl = "http://view.xdocin.com/xdoc?_xdoc=";
//                for(HiddenDangerCheck hdc : resultList) {
//                    //设置基础清单排查的清单文件
//                    //排查类型(1基础清单排查 2选择风险单元清单排查)
//                    if (!StringUtil.isEmpty(hdc.getCheckType()) && "1".equals(hdc.getCheckType())) {
//                        hdc.setBasicListFileUrl(xdocinUrl + hdc.getBasicListFile());
//                    }
//                }
                return ApiResult.success("请求数据成功", resultList);
            }
        } catch (Exception e) {
            return ApiResult.error("异常");
        }
    }
 
 
 
    /**
     * 定时隐患排查保存
     */
    public ApiResult editDangerScheduleSave(String str, ApiRequestHeader header) {
        //验证userId,loginName,token,deviceType,deviceId,appType 是否一致
        ApiRequestHeader requestHeader = getHeader(header);
        if (!(header.equals(requestHeader))) {
            return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
        }
        try {
            HiddenDangerCheck hiddenDangerCheck = new ObjectMapper().readValue(str, HiddenDangerCheck.class);
            hiddenDangerCheck.setScheduleCheckStatus(TrHiddenDangerCheckConstants.CHECK_STATUS_ALREADY_CHECK);//排查状态(已排查)
            hiddenDangerCheck.setCheckTime(DateUtils.getNowDate());//设置排查时间
            hiddenDangerCheck.setUpdateBy(header.loginName);
            hiddenDangerCheck.setUpdateTime(DateUtils.getNowDate());
            HiddenDangerCheckPoint hdcpTemp = new HiddenDangerCheckPoint();
            hdcpTemp.setCheckId(hiddenDangerCheck.getCheckId());
            List<HiddenDangerCheckPoint> hdcpList = hdcpService.selectHiddenDangerCheckPointList(hdcpTemp);
 
            for (HiddenDangerCheckPoint hdcp : hdcpList) {
                if(StringUtils.isEmpty(hdcp.getWhetherDanger())){
                    return ApiResult.error("检查点需全部操作,请操作检查点。");
                }
            }
 
            hdcpList.forEach(hdcp-> {
                if (hdcp != null) {
                    hdcp.setUpdateBy(header.loginName);
                    hdcp.setUpdateTime(DateUtils.getNowDate());
                    //是隐患设置核查人ID、核查人名称
                    if((!StringUtils.isEmpty(hdcp.getWhetherDanger()))&&
                            (TrHiddenDangerCheckConstants.WHETHER_DANGER_YES.equals(hdcp.getWhetherDanger()))) {
                        hdcp.setExamineStatus(TrHiddenDangerCheckConstants.EXAMINE_STATUS_NOT_EXAMINE);//核查状态(待核查)
                        hdcp.setExamineUserId(hiddenDangerCheck.getExamineUserId());//核查人ID
                        hdcp.setExamineUserName(hiddenDangerCheck.getExamineUserName());//核查人名称
                        hdcp.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_EXAMINE);//3隐患核查阶段(/** 更新者 */数据进入到3隐患核查阶段)
                    }
                    hdcpService.updateHiddenDangerCheckPoint(hdcp);
                }
            });
 
            hiddenDangerCheckService.updateHiddenDangerCheck(hiddenDangerCheck);
 
            hdcpService.getTaskCountTotal(Long.valueOf(header.userId));//查询未执行任务总数量并推送
 
            return ApiResult.success("定时隐患排查--保存成功");
        } catch (Exception e) {
            return ApiResult.error("异常");
        }
    }
 
 
 
 
    /**
     * 设置为记录正常 todo
     */
    public ApiResult editPointScheduleSetNormal(String str, ApiRequestHeader header) {
        //验证userId,loginName,token,deviceType,deviceId,appType 是否一致
        ApiRequestHeader requestHeader = getHeader(header);
        if (!(header.equals(requestHeader))) {
            return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
        }
        try {
            HiddenDangerCheckPoint hdcp = new ObjectMapper().readValue(str, HiddenDangerCheckPoint.class);
            hdcp.setUpdateBy(header.loginName);
            hdcp.setUpdateTime(DateUtils.getNowDate());
            hdcp.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_NOT);//是否为隐患(正常)
            hdcp.setScheduleCheckStatus(TrHiddenDangerCheckConstants.CHECK_STATUS_ALREADY_CHECK);//排查状态(已排查)
            hdcpService.updateHiddenDangerCheckPoint(hdcp);
 
            PreventRiskDangerCheckAndMeasure dangerCheckPointInfo = preventRiskDangerCheckAndMeasureService.getByDangerCheckPointId(hdcp.getId());
            int result = riskService.updateCheckLog(dangerCheckPointInfo.getCheckId(), hdcp);
            if (result < 1){
                return ApiResult.error("隐患排查记录附属表:写入手机识别码错误");
            }
 
            //添加检查说明信息
            int result1 = riskDangerCheckAndMeasureService.updateCheckDesc(hdcp);
            if (result1 < 1){
                throw new RuntimeException("登记检查上报结果失败");
            }
            hdcpService.getTaskCountTotal(Long.valueOf(header.userId));//查询未执行任务总数量并推送
 
            return ApiResult.success("定时隐患排查--设置为正常--成功");
        } catch (Exception e) {
            return ApiResult.error("异常");
        }
    }
 
 
 
    /**
     * 定时隐患排查---隐患登记
     */
    @Transactional
    public ApiResult editPointScheduleDangerRegisterSave(String str, ApiRequestHeader header) {
        //验证userId,loginName,token,deviceType,deviceId,appType 是否一致
        ApiRequestHeader requestHeader = getHeader(header);
        if (!(header.equals(requestHeader))) {
            return ApiResult.errorToken("验证userId,loginName,token,deviceType,deviceId,appType 不一致");
        }
        try {
            HiddenDangerCheckPoint hdcp = new ObjectMapper().readValue(str, HiddenDangerCheckPoint.class);
            if (ObjectUtils.isEmpty(hdcp.getCheckPerson())){
                throw new RuntimeException("检查人不能为空");
            }
            if (ObjectUtils.isEmpty(hdcp.getFindTime())){
                throw new RuntimeException("发现时间不能为空");
            }
            if(ObjectUtils.isEmpty(hdcp.getDangerSrc())){
                throw new RuntimeException("隐患来源不能为空");
            }
            hdcp.setUpdateBy(header.loginName);
            hdcp.setUpdateTime(DateUtils.getNowDate());
            hdcp.setRegisterCreateTime(DateUtils.getNowDate());//设置隐患登记上报创建时间
            hdcp.setRegisterUserId(Long.valueOf(header.userId));//设置隐患登记上报创建人ID
            User user = userService.selectUserById(Long.valueOf(header.userId));
            hdcp.setRegisterUserName(user.getUserName());//设置隐患登记上报创建人名称
            hdcp.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_YES);//是否为隐患(是隐患)
            hdcp.setScheduleCheckStatus(TrHiddenDangerCheckConstants.CHECK_STATUS_ALREADY_CHECK);//排查状态(已排查)
            hdcp.setExamineStatus(TrHiddenDangerCheckConstants.EXAMINE_STATUS_NOT_EXAMINE);//核查状态(待核查)
            hdcp.setStage(TrHiddenDangerCheckConstants.DANGER_STAGE_PLAN_EXAMINE);//隐患核查阶段(数据进入到隐患核查阶段)
            hdcp.setDangerSources(TrHiddenDangerCheckConstants.DANGER_SOURCES_SCHEDULE_PRODUCE); //隐患来源(定时器任务生成)
 
            HiddenDangerCheckPoint queryExist = new HiddenDangerCheckPoint();
            queryExist.setWhetherDanger(TrHiddenDangerCheckConstants.WHETHER_DANGER_YES);//是否为隐患(是隐患)
            queryExist.setCheckPointId(hdcp.getCheckPointId());
            queryExist.setCheckId(hdcp.getCheckId());
 
            hdcp.setReportStatus("0");
 
            /**
             * 本次查询结果 :如果未上报过隐患,必定为空
             *      同一个检查任务,同一个排查点,可能多次上报隐患。
             *      本次查询未用到id,导致数据不唯一
             * */
            List<HiddenDangerCheckPoint> queryExistList =  hdcpService.selectHiddenDangerCheckPointList(queryExist);
            int i=0;
            //如果隐患信息已经存在,就新插入一条;如果不存在,就修改隐患信息
            if(queryExistList.size()>0){
                hdcp.setId(null);
                hdcp.setCheckTime(DateUtils.getNowDate());
                hdcp.setCreateBy(user.getLoginName());
                hdcp.setCreateTime(DateUtils.getNowDate());
 
                hdcp.setCompanyId(user.getCompanyId());
                i = hdcpService.insertHiddenDangerCheckPoint(hdcp);
                if (i< 1){
                    throw new RuntimeException("添加隐患信息失败");
                }
 
                //获取Id返回值   20250623 放开
                hdcp.getId();
                int result = riskService.insertDangerInfo(hdcp.getId(), hdcp);
                if (result< 1){
                    throw new RuntimeException("添加隐患附属信息失败");
                }
 
//                PreventRiskDangerCheckAndMeasure dangerCheckPointInfo = preventRiskDangerCheckAndMeasureService.getByDangerCheckPointId(hdcp.getId());
//                riskService.updateCheckLog(dangerCheckPointInfo.getCheckId(), hdcp);
 
            }else{
                hdcp.setUpdateBy(user.getLoginName());
                hdcp.setUpdateTime(DateUtils.getNowDate());
                i = hdcpService.updateHiddenDangerCheckPoint(hdcp);
 
                PreventRiskDangerInfo dangerInfoByDangerCheckPointId = riskService.getDangerInfoByDangerCheckPointId(hdcp.getId());
                if (dangerInfoByDangerCheckPointId != null){
                    // todo-2022 此处修改附属表 20250623 放开
                    int result = riskService.updateDangerInfo(hdcp);
                    if (result < 1){
                        throw new RuntimeException("修改失败");
                    }
                }else {
                    int result = riskService.insertDangerInfo(hdcp.getId(), hdcp);
                    if (result < 1){
                        throw new RuntimeException("修改失败");
                    }
                }
 
//                int result = riskService.insertDangerInfo(hdcp.getId(), hdcp);
//                if (result< 1){
//                    throw new RuntimeException("添加隐患附属信息失败");
//                }
 
                PreventRiskDangerCheckAndMeasure dangerCheckPointInfo = preventRiskDangerCheckAndMeasureService.getByDangerCheckPointId(hdcp.getId());
                riskService.updateCheckLog(dangerCheckPointInfo.getCheckId(), hdcp);
            }
            hdcpService.getTaskCountTotal(Long.valueOf(header.userId));//查询未执行任务总数量并推送
 
            return ApiResult.success("定时隐患排查--隐患登记--成功");
        } catch (Exception e) {
            return ApiResult.error(e.getMessage());
        }
    }
}