郑永安
2023-06-19 59e91a4e9ddaf23cebb12993c774aa899ab22d16
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
package com.gk.firework.Scheduls.Task;
 
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.gk.firework.Config.WebSocket.WebSocketServer;
import com.gk.firework.Domain.Enterprise;
import com.gk.firework.Domain.EnterpriseLicense;
import com.gk.firework.Domain.EnterprisePerson;
import com.gk.firework.Domain.Enum.EnterpriseSafetySupervision;
import com.gk.firework.Domain.Enum.MsgContentType;
import com.gk.firework.Domain.Enum.MsgType;
import com.gk.firework.Domain.Enum.PersonnelCategory;
import com.gk.firework.Domain.UserInfo;
import com.gk.firework.Domain.Utils.Message;
import com.gk.firework.Domain.Utils.SpringBeanUtil;
import com.gk.firework.Domain.Utils.StringUtils;
import com.gk.firework.Service.EnterpriseLicenseService;
import com.gk.firework.Service.EnterprisePersonService;
import com.gk.firework.Service.EnterpriseService;
import lombok.SneakyThrows;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Scope;
import org.springframework.stereotype.Component;
import org.springframework.stereotype.Service;
 
import javax.websocket.Session;
import java.util.ArrayList;
import java.util.Date;
 
@Component("task")
@Scope("prototype")
public class CheckEnterpriseTask implements Runnable{
 
    final static Logger logger= LoggerFactory.getLogger(CheckEnterpriseTask.class);
 
    private UserInfo userInfo;
 
 
    public CheckEnterpriseTask(UserInfo userInfo) {
        this.userInfo = userInfo;
    }
 
    @SneakyThrows
    @Override
    public void run() {
        String companynumber = userInfo.getCompanynumber();
        Long companyid = userInfo.getCompanyid();
        //普通企业
        if (StringUtils.isNotBlank(companynumber)) {
            logger.info("正在执行:检查企业信息是否完善");
            Enterprise enterprise = SpringBeanUtil.getBean(EnterpriseService.class).selectEnterpriseByNumber(companynumber);
            Message message = new Message(MsgType.NOTIFICATION,MsgContentType.INFO_UNDONE,Boolean.FALSE);
            ArrayList<String> msgs = new ArrayList<>();
            if (!checkEnterprise(enterprise)) msgs.add("企业相关信息还未完善");
            if (!checkEnterpriseLicense(companyid)) msgs.add("许可证信息还未完善");
            if (!checkSafetyPerson(companyid)) msgs.add("安全人员信息还未完善");
            //长期店、短期店不用特种人员
            if (!checkSpecialPerson(companyid)
                    && (enterprise.getSafetysupervision().equals(EnterpriseSafetySupervision.PRODUCE)
                    || enterprise.getSafetysupervision().equals(EnterpriseSafetySupervision.WHOLESALER))
            ) msgs.add("特种人员信息还未完善");
            if (msgs.size() > 0){
                message.setMessage(msgs.toString());
                WebSocketServer.sendMessage(userInfo.getId(), JSONObject.toJSONString(message));
            }
 
            //检查许可证过期
            logger.info("正在执行:检查企业许可证是否过期");
            if (enterprise.getValidendtime().before(new Date())) {
                Message message2 = new Message(MsgType.NOTIFICATION,MsgContentType.LICENSE_EXPIRED,Boolean.FALSE);
                message2.setMessage("您的许可证已到期,请重新录入许可证期限并上传许可证");
                WebSocketServer.sendMessage(userInfo.getId(), JSONObject.toJSONString(message2));
            }
        }
        //监管部门
        if (StringUtils.isBlank(companynumber)) {
            //查找管辖的所有企业的信息未完善的
            logger.info("正在执行:检查企业信息未完善个数");
            int undoneEnterprise = SpringBeanUtil.getBean(EnterpriseService.class).countAllUndoneEnterprise(userInfo);
            if (undoneEnterprise > 0) {
                Message message = new Message(MsgType.NOTIFICATION, MsgContentType.INFO_UNDONE, Boolean.TRUE);
                message.setMessage(String.format("共有%d个企业未完善企业相关信息",undoneEnterprise));
                WebSocketServer.sendMessage(userInfo.getId(), JSONObject.toJSONString(message));
            }
 
            logger.info("正在执行:检查所有许可证过期企业");
            int expiredEnterprise = SpringBeanUtil.getBean(EnterpriseService.class).countAllEnterpriseExpired(userInfo);
            if (expiredEnterprise > 0) {
                Message message = new Message(MsgType.NOTIFICATION, MsgContentType.LICENSE_EXPIRED, Boolean.TRUE);
                message.setMessage(String.format("共有%d个企业许可证已过期",expiredEnterprise));
                WebSocketServer.sendMessage(userInfo.getId(), JSONObject.toJSONString(message));
            }
 
        }
        logger.info("结束执行");
 
    }
 
    //检查企业信息完整
    private boolean checkEnterprise(Enterprise enterprise) {
        boolean flag = true;
        //小提示
        if (StringUtils.isBlank(enterprise.getOfficeaddress())) {
            flag = false;
        }
        return flag;
    }
 
    //检查许可证 有无
    private boolean checkEnterpriseLicense(Long enterpriseid) {
        LambdaQueryWrapper<EnterpriseLicense> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(EnterpriseLicense::getEnterpriseid, enterpriseid)
                .eq(EnterpriseLicense::getValidflag, true);
        int count = SpringBeanUtil.getBean(EnterpriseLicenseService.class).count(queryWrapper);
        return count != 0;
    }
 
 
    //检查安全人员
    private boolean checkSafetyPerson(Long enterpriseid) {
        LambdaQueryWrapper<EnterprisePerson> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(EnterprisePerson::getEnterpriseid, enterpriseid)
                .eq(EnterprisePerson::getValidflag, true)
                .eq(EnterprisePerson::getType, PersonnelCategory.SECURITY);
        int count = SpringBeanUtil.getBean(EnterprisePersonService.class).count(queryWrapper);
        return count != 0;
    }
 
    //检查特种人员
    private boolean checkSpecialPerson(Long enterpriseid) {
        LambdaQueryWrapper<EnterprisePerson> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(EnterprisePerson::getEnterpriseid, enterpriseid)
                .eq(EnterprisePerson::getValidflag, true)
                .eq(EnterprisePerson::getType, PersonnelCategory.SPECIAL);
        int count = SpringBeanUtil.getBean(EnterprisePersonService.class).count(queryWrapper);
        return count != 0;
    }
 
 
 
 
 
}