2024-04-13 17:35:21 +08:00

283 lines
14 KiB
Java
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

package com.zhgd.xmgl.task;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.zhgd.xmgl.modules.basicdata.entity.SystemUser;
import com.zhgd.xmgl.modules.basicdata.mapper.SystemLogoConfigMapper;
import com.zhgd.xmgl.modules.basicdata.mapper.SystemUserMapper;
import com.zhgd.xmgl.modules.basicdata.service.INoticeService;
import com.zhgd.xmgl.modules.project.entity.Project;
import com.zhgd.xmgl.modules.project.entity.ProjectExternalSystemService;
import com.zhgd.xmgl.modules.project.mapper.ProjectExternalSystemServiceMapper;
import com.zhgd.xmgl.modules.project.mapper.ProjectMapper;
import com.zhgd.xmgl.modules.project.service.IProjectUfaceConfigService;
import com.zhgd.xmgl.modules.worker.entity.WorkerBlacklist;
import com.zhgd.xmgl.modules.worker.entity.WorkerInfo;
import com.zhgd.xmgl.modules.worker.mapper.WorkerAttendancePresenceMapper;
import com.zhgd.xmgl.modules.worker.mapper.WorkerBlacklistMapper;
import com.zhgd.xmgl.modules.worker.mapper.WorkerCertificateMapper;
import com.zhgd.xmgl.modules.worker.mapper.WorkerInfoMapper;
import com.zhgd.xmgl.modules.worker.service.IWorkerAttendancePresenceService;
import com.zhgd.xmgl.modules.worker.service.IWorkerCertificateService;
import com.zhgd.xmgl.util.ElecardUtil;
import lombok.extern.slf4j.Slf4j;
import net.javacrumbs.shedlock.core.SchedulerLock;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Collection;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* @program: wisdomSite
* @description: 劳务人员定时任务
* @author: Mr.Peng
* @create: 2021-09-10 17:31
**/
@Slf4j
@Component
@RestController
@RequestMapping("xmgl/task")
public class WorkerTask {
@Autowired
private ProjectExternalSystemServiceMapper projectExternalSystemServiceMapper;
@Autowired
private WorkerInfoMapper workerInfoMapper;
@Autowired
private ProjectMapper projectMapper;
@Autowired
private SystemUserMapper systemUserMapper;
@Autowired
private SystemLogoConfigMapper systemLogoConfigMapper;
@Autowired
private IWorkerAttendancePresenceService workerAttendancePresenceService;
@Autowired
private INoticeService noticeService;
@Autowired
private IProjectUfaceConfigService projectUfaceConfigService;
@Autowired
private IWorkerCertificateService workerCertificateService;
@Autowired
private WorkerCertificateMapper workerCertificateMapper;
@Autowired
private WorkerBlacklistMapper workerBlacklistMapper;
@Autowired
private WorkerAttendancePresenceMapper workerAttendancePresenceMapper;
/**
* 定时修改用户码状态
*/
@SchedulerLock(name = "updateWorkerCode", lockAtMostFor = 1000 * 60 * 60, lockAtLeastFor = 1000 * 60 * 5)
@Scheduled(cron = "0 0 1 * * ?")
public void updateWorkerCode() {
log.info("------------------------------健康码同步开始-----------------------------------------");
try {
List<ProjectExternalSystemService> list = projectExternalSystemServiceMapper.getChangtongCodeSystemList();
if (list != null && list.size() > 0) {
for (ProjectExternalSystemService projectExternalSystemService : list) {
getWorkerCodeState(projectExternalSystemService);
}
}
} catch (Exception e) {
e.printStackTrace();
}
log.info("------------------------------健康码同步结束-----------------------------------------");
}
public void getWorkerCodeState(ProjectExternalSystemService projectExternalSystemService) {
try {
List<WorkerInfo> list = workerInfoMapper.selectAllWorkerInfoList(projectExternalSystemService.getProjectSn());
if (list != null && list.size() > 0) {
String token = ElecardUtil.getToken(projectExternalSystemService.getSystemUrl(), projectExternalSystemService.getAppId(), projectExternalSystemService.getAppSecert(),
projectExternalSystemService.getPublicKey(), projectExternalSystemService.getPrivateKey());
if (StringUtils.isNotEmpty(token)) {
int redNum = 0;
int orangeNum = 0;
StringBuilder redWorkerName = new StringBuilder();
StringBuilder orangeWorkerName = new StringBuilder();
for (WorkerInfo workerInfo : list) {
log.info("---------------" + workerInfo.getWorkerName());
String enterStatus = ElecardUtil.getCardInfo(projectExternalSystemService.getSystemUrl(), projectExternalSystemService.getAppId(), projectExternalSystemService.getAppSecert(),
projectExternalSystemService.getPublicKey(), projectExternalSystemService.getPrivateKey(), token, workerInfo.getIdCard());
//0 :绿色, 1:黄色 ,2:红色
//红黄码需设备取消授权不允许通行
if (StringUtils.isNotEmpty(enterStatus)) {
if ("2".equals(enterStatus)) {
redNum++;
if (redWorkerName.length() > 0) {
redWorkerName.append("");
}
redWorkerName.append(workerInfo.getWorkerName());
//码状态0无码1红2黄3绿
workerInfo.setCodeState(1);
workerInfo.setUfaceDevId("0");
projectUfaceConfigService.deleteWorkerInfo(workerInfo);
} else if ("1".equals(enterStatus)) {
orangeNum++;
if (orangeWorkerName.length() > 0) {
orangeWorkerName.append("");
}
orangeWorkerName.append(workerInfo.getWorkerName());
workerInfo.setCodeState(2);
workerInfo.setUfaceDevId("0");
projectUfaceConfigService.deleteWorkerInfo(workerInfo);
} else {
workerInfo.setCodeState(3);
}
workerInfoMapper.updateById(workerInfo);
}
}
if (redNum > 0 || orangeNum > 0) {
//String title="今日昌通码核验黄码"+orangeNum+"人,红码"+redNum+"人";
StringBuilder title = new StringBuilder();
title.append("今日昌通码核验黄码").append(orangeNum).append("人,");
if (orangeWorkerName.length() > 0) {
title.append("分别为:").append(orangeWorkerName.toString()).append("");
}
title.append("红码").append(redNum).append("");
if (redWorkerName.length() > 0) {
title.append("分别为:").append(redWorkerName.toString()).append("");
}
StringBuilder title2 = new StringBuilder();
if (orangeWorkerName.length() > 0) {
title2.append("黄码人员:").append(orangeWorkerName.toString()).append("");
}
if (redWorkerName.length() > 0) {
title2.append("红码人员:").append(redWorkerName.toString()).append("");
}
title2.append("已销权");
noticeService.sendProjectNoicte(projectExternalSystemService.getProjectSn(), "红黄码核验", title.toString(), "17");
noticeService.sendProjectNoicte(projectExternalSystemService.getProjectSn(), "红黄码销权", title2.toString(), "17");
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 劳务人员,截止日期到期的话(包括人员的合同信息、资格证书、保险信息),就自动填充原因,就是证件到期到黑名单中
*/
@SchedulerLock(name = "addWorkerBlacklist", lockAtMostFor = 1000 * 60 * 60, lockAtLeastFor = 1000 * 60 * 5)
@Scheduled(cron = "0 0 1 * * ?")
@RequestMapping("/addWorkerBlacklist")
public void addWorkerBlacklist() {
log.info("任务开始,劳务人员,截止日期到期的话(包括人员的合同信息、资格证书、保险信息),到黑名单");
//证书过期
List<WorkerInfo> list = workerCertificateMapper.selectExpiredCertificateNotInBlackWorkerList();
addWorkerBlacklist(list, "证件已到期", 1);
//合同过期
List<WorkerInfo> list1 = workerCertificateMapper.selectExpiredContractNotInBlackWorkerList();
addWorkerBlacklist(list1, "合同已到期", 2);
//保险过期
List<WorkerInfo> list2 = workerCertificateMapper.selectExpiredInsuranceNotInBlackWorkerList();
addWorkerBlacklist(list2, "保险已到期", 3);
}
private void addWorkerBlacklist(List<WorkerInfo> list, String addReason, int type) {
for (WorkerInfo workerInfo : list) {
WorkerBlacklist black = new WorkerBlacklist();
black.setProjectSn(workerInfo.getProjectSn());
black.setWorkerId(workerInfo.getId());
black.setWorkerName(workerInfo.getWorkerName());
black.setIdCard(workerInfo.getIdCard());
black.setAddReason(addReason);
black.setReason(addReason);
black.setAddTime(DateUtil.now());
black.setCreateTime(new Date());
black.setType(type);
workerBlacklistMapper.insert(black);
}
}
/**
* 对人员的资质证书到期进行预警,预警后发送消息提示项目管理员账号
* 系统设置:开启后将会在对企业下的各个项目开启人员证书到期预警提示,提前预警时间可以自行设置,监测内容包括人员的合同信息、资格证书、保险信息。
*/
@SchedulerLock(name = "alarmWorkerBlack", lockAtMostFor = 1000 * 60 * 60, lockAtLeastFor = 1000 * 60 * 5)
@Scheduled(cron = "0 0 1 * * ?")
@RequestMapping("/alarmWorkerBlack")
public void alarmWorkerBlack() {
log.info("任务开始,对人员的合同信息、资格证书、保险信息到期进行预警,预警后发送消息提示项目管理员账号");
//资格证书预警
List<WorkerInfo> list1 = workerCertificateMapper.getAlarmWorkerCertificateWithHeadquarter();
List<WorkerInfo> list2 = workerCertificateMapper.getAlarmWorkerCertificateNotHeadquarter();
addNotice(CollUtil.addAll(list1, list2), "人员的资质证书即将到期", null, "20");
//合同信息预警
List<WorkerInfo> list3 = workerCertificateMapper.getAlarmWorkerContractWithHeadquarter();
List<WorkerInfo> list4 = workerCertificateMapper.getAlarmWorkerContractNotHeadquarter();
addNotice(CollUtil.addAll(list3, list4), "人员的合同信息即将到期", "合同信息", "21");
//保险信息预警
List<WorkerInfo> list5 = workerCertificateMapper.getAlarmWorkerInsuranceWithHeadquarter();
List<WorkerInfo> list6 = workerCertificateMapper.getAlarmWorkerInsuranceNotHeadquarter();
addNotice(CollUtil.addAll(list5, list6), "人员的保险信息即将到期", "保险信息", "22");
}
/**
* 添加通知
*
* @param list
* @param title 标题
* @param book 具体的某项
* @param type
*/
private void addNotice(Collection<WorkerInfo> list, String title, String book, String type) {
Map<String, List<WorkerInfo>> projectMap = list.stream().collect(Collectors.groupingBy(WorkerInfo::getProjectSn));
if (CollUtil.isNotEmpty(projectMap)) {
for (Map.Entry<String, List<WorkerInfo>> entry : projectMap.entrySet()) {
List<SystemUser> systemUserList = systemUserMapper.selectList(new LambdaQueryWrapper<SystemUser>()
.eq(SystemUser::getSn, entry.getKey()));
List<WorkerInfo> workerInfoList = entry.getValue();
if (CollUtil.isNotEmpty(workerInfoList)) {
for (WorkerInfo workerInfo : workerInfoList) {
if (CollUtil.isNotEmpty(systemUserList)) {
for (SystemUser systemUser : systemUserList) {
String name = "";
if (StringUtils.isNotBlank(book)) {
name = book;
} else {
name = workerInfo.getCertificateTypeName();
}
noticeService.addUserNotice(systemUser.getUserId(), workerInfo.getWorkerName() + "" + name + "即将到期,请尽快更新!", title, type);
}
}
}
}
}
}
}
/**
* 劳务在场零点清空功能
*/
@Scheduled(cron = "0 10 0 * * ?")
@SchedulerLock(name = "updateWorkerAttendanceZero", lockAtMostFor = 1000 * 60 * 30, lockAtLeastFor = 1000 * 60 * 3)
@RequestMapping("updateWorkerAttendanceZero")
public void updateWorkerAttendanceZero() {
List<Project> projects = projectMapper.selectList(new LambdaQueryWrapper<Project>()
.eq(Project::getEnableWorkerAttendanceZero, 1));
for (Project project : projects) {
String projectSn = project.getProjectSn();
workerAttendancePresenceService.addNowAllWorkerAttendancePresence(projectSn);
}
}
}