neim/neim-biz/src/main/java/com/jiayue/biz/service/impl/EmailImpl.java

package com.jiayue.biz.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.jiayue.biz.domain.Email;
import com.jiayue.biz.domain.EmailWindTowerInfo;
import com.jiayue.biz.domain.WindTowerInfo;
import com.jiayue.biz.mapper.EmailMapper;
import com.jiayue.biz.service.EmailService;
import com.jiayue.biz.service.EmailWindTowerInfoService;
import com.jiayue.biz.util.FileUtil;
import com.sun.mail.imap.IMAPFolder;
import com.sun.mail.imap.IMAPStore;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.mail.*;
import javax.mail.internet.InternetAddress;
import javax.mail.internet.MimeMessage;
import javax.mail.internet.MimeMultipart;
import javax.mail.internet.MimeUtility;
import javax.mail.search.*;
import java.io.*;
import java.security.Security;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 使用imap协议获取未读邮件数
 *
 * @author w
 */
@Slf4j
@Service
public class EmailImpl extends ServiceImpl<EmailMapper, Email> implements EmailService {
    @Value("${email.user}")
    private String user;

    @Value("${email.password}")
    private String password;

    @Value("${email.host}")
    private String host;

    @Value("${email.path}")
    private String path;

    @Value("${file.outPutDir}")
    private String outPutDir;

    @Autowired
    EmailService emailService;

    private final WindTowerInfoServiceImpl windTowerInfoService;
    private final EmailWindTowerInfoService emailWindTowerInfoService;
    private final AnalysisDataImpl analysisDataService;

    public EmailImpl(WindTowerInfoServiceImpl windTowerInfoService, EmailWindTowerInfoService emailWindTowerInfoService, AnalysisDataImpl analysisDataService) {
        this.windTowerInfoService = windTowerInfoService;
        this.emailWindTowerInfoService = emailWindTowerInfoService;
        this.analysisDataService = analysisDataService;
    }

    /**
     * 获取所有邮件账号信息
     *
     * @return
     */
    public List<Email> selectEmail() {
        return emailService.list();
    }

    public void readMail(String str) {
        List<Email> emails = this.selectEmail();
        for (Email email : emails) {

            user = email.getUserName();
            password = email.getPassword();
            host = email.getHost();
            path = email.getPath();

            Security.addProvider(new com.sun.net.ssl.internal.ssl.Provider());
            Properties prop = System.getProperties();
            prop.put("mail.imap.port", "993");
            prop.put("mail.imap.ssl.enable", true);
            //如果设置，并且未指定套接字工厂，则启用MailSSLSocketFactory的使用。 如果设置为“ *”，则所有主机都是受信任的。
            //如果设置为以空格分隔的主机列表，则这些主机是可信任的。 否则，信任取决于服务器提供的证书。(设置主机可信任)
            prop.put("mail.imap.ssl.trust", host);
            //这部分就是解决异常的关键所在，设置IAMP ID信息
            HashMap IAM = new HashMap();
            //带上IMAP ID信息，由key和value组成，例如name，version，vendor，support-email等。
            // 这个value的值随便写就行
            IAM.put("name", "myname");
            IAM.put("version", "1.0.0");
            IAM.put("vendor", "myclient");
            IAM.put("support-email", "testmail@test.com");
            try {
                Session session = Session.getDefaultInstance(prop, null);
                session.setDebug(false);
                IMAPStore store = (IMAPStore) session.getStore("imap"); // 使用imap会话机制，连接服务器
                store.connect(host, user, password);
                store.id(IAM);
                IMAPFolder folder = (IMAPFolder) store.getFolder("INBOX"); // 收件箱
                /*
                 * Folder.READ_ONLY：只读权限
                 * Folder.READ_WRITE：可读可写（可以修改邮件的状态）
                 */
                folder.open(Folder.READ_WRITE); //打开收件箱
                // 获得收件箱中的未读邮件数
                log.warn("未读邮件数: {}", folder.getUnreadMessageCount());
                log.warn("总邮件个数: {}", folder.getMessageCount());
                Message[] messages1 = null;
                FlagTerm ft = new FlagTerm(new Flags(Flags.Flag.SEEN), false); //false代表未读，true代表已读
                if (!"all".equals(str)) {
                    Calendar cal = Calendar.getInstance();
                    cal.add(Calendar.DAY_OF_MONTH, -10);
                    SearchTerm term = new SentDateTerm(ComparisonTerm.GE, cal.getTime());
                    SearchTerm comparisonAndTerm = new AndTerm(term, ft);
                    messages1 = folder.search(comparisonAndTerm);
                } else {
                    messages1 = folder.search(ft);
                }

                for (Message message : messages1) {
                    //存在附件返回true 不存在返回false

                    //未读
                    Multipart m = (Multipart) message.getContent();
                    for (int s = 0; s < m.getCount(); s++) {
                        BodyPart mimeMultipart = m.getBodyPart(s);
                        log.info(mimeMultipart.getFileName());
                    }
                    //解析邮件
                    parseMessage(message);

                }

                //释放资源
                folder.close(true);
                store.close();
            } catch (Exception e) {
                log.error("读取邮件异常" + e);
            }
        }
    }

    public void parseMessage(Message... messages) throws MessagingException, IOException {
        if (messages == null || messages.length < 1) {
            throw new MessagingException("未找到要解析的邮件!");
        }

        // 解析所有邮件
        for (int i = 0, count = messages.length; i < count; i++) {
            MimeMessage msg = (MimeMessage) messages[i];
            log.info("------------------解析第" + msg.getMessageNumber() + "封邮件-------------------- ");
            boolean isContainerAttachment = isContainAttachment(msg);
            File file = new File(path);
            if (!file.exists()) {
                file.mkdirs();
            }
            if (isContainerAttachment) {
                saveAttachment(msg, path); //保存附件
            }
            StringBuffer content = new StringBuffer(30);
            //解析邮件正文
            getMailTextContent(msg, content);
            //邮件设置为已读
            isTrue(msg);
            log.info("------------------第" + msg.getMessageNumber() + "封邮件解析结束-------------------- ");
        }
        //执行系统命令转为txt文件sdf.parse("20220428")
        systemCommand();
    }

    /**
     * 获得邮件主题
     *
     * @param msg 邮件内容
     * @return 解码后的邮件主题
     */
    public String getSubject(MimeMessage msg) throws UnsupportedEncodingException, MessagingException {
        return MimeUtility.decodeText(msg.getSubject());
    }

    /**
     * 获得邮件发件人
     *
     * @param msg 邮件内容
     * @return 姓名 <Email地址>
     * @throws MessagingException
     * @throws UnsupportedEncodingException
     */
    public String getFrom(MimeMessage msg) throws MessagingException, UnsupportedEncodingException {
        String from = "";
        Address[] froms = msg.getFrom();
        if (froms.length < 1)
            throw new MessagingException("没有发件人!");

        InternetAddress address = (InternetAddress) froms[0];
        String person = address.getPersonal();
        if (person != null) {
            person = MimeUtility.decodeText(person) + " ";
        } else {
            person = "";
        }
        from = person + "<" + address.getAddress() + ">";

        return from;
    }

    /**
     * 根据收件人类型，获取邮件收件人、抄送和密送地址。如果收件人类型为空，则获得所有的收件人
     * <p>Message.RecipientType.TO  收件人</p>
     * <p>Message.RecipientType.CC  抄送</p>
     * <p>Message.RecipientType.BCC 密送</p>
     *
     * @param msg  邮件内容
     * @param type 收件人类型
     * @return 收件人1 <邮件地址1>, 收件人2 <邮件地址2>, ...
     * @throws MessagingException
     */
    public String getReceiveAddress(MimeMessage msg, Message.RecipientType type) throws MessagingException {
        StringBuffer receiveAddress = new StringBuffer();
        Address[] addresss = null;
        if (type == null) {
            addresss = msg.getAllRecipients();
        } else {
            addresss = msg.getRecipients(type);
        }

        if (addresss == null || addresss.length < 1)
            throw new MessagingException("没有收件人!");
        for (Address address : addresss) {
            InternetAddress internetAddress = (InternetAddress) address;
            receiveAddress.append(internetAddress.toUnicodeString()).append(",");
        }

        receiveAddress.deleteCharAt(receiveAddress.length() - 1); //删除最后一个逗号

        return receiveAddress.toString();
    }

    /**
     * 获得邮件发送时间
     *
     * @param msg 邮件内容
     * @return yyyy年mm月dd日 星期X HH:mm
     * @throws MessagingException
     */
    public String getSentDate(MimeMessage msg, String pattern) throws MessagingException {
        Date receivedDate = msg.getSentDate();
        if (receivedDate == null)
            return "";

        if (pattern == null || "".equals(pattern))
            pattern = "yyyy年MM月dd日 E HH:mm ";

        return new SimpleDateFormat(pattern).format(receivedDate);
    }

    /**
     * 判断邮件中是否包含附件
     *
     * @param part 邮件内容
     * @return 邮件中存在附件返回true，不存在返回false
     * @throws MessagingException
     * @throws IOException
     */
    public boolean isContainAttachment(Part part) throws MessagingException, IOException {
        boolean flag = false;
        if (part.isMimeType("multipart/*")) {
            MimeMultipart multipart = (MimeMultipart) part.getContent();
            int partCount = multipart.getCount();
            for (int i = 0; i < partCount; i++) {
                BodyPart bodyPart = multipart.getBodyPart(i);
                String disp = bodyPart.getDisposition();
                if (disp != null && (disp.equalsIgnoreCase(Part.ATTACHMENT) || disp.equalsIgnoreCase(Part.INLINE))) {
                    flag = true;
                } else if (bodyPart.isMimeType("multipart/*")) {
                    flag = isContainAttachment(bodyPart);
                } else {
                    String contentType = bodyPart.getContentType();
                    if (contentType.indexOf("application") != -1) {
                        flag = true;
                    }

                    if (contentType.indexOf("name") != -1) {
                        flag = true;
                    }
                }

                if (flag) break;
            }
        } else if (part.isMimeType("message/rfc822")) {
            flag = isContainAttachment((Part) part.getContent());
        }
        return flag;
    }

    /**
     * 判断邮件是否已读 imap有效 pop3无效
     *
     * @param msg 邮件内容
     * @return 如果邮件已读返回true, 否则返回false
     * @throws MessagingException
     */
    public boolean isSeen(MimeMessage msg) throws MessagingException {
        return msg.getFlags().contains(Flags.Flag.SEEN);
    }

    /**
     * 设置邮件为已读
     *
     * @param msg 邮件内容
     * @throws MessagingException
     */
    public void isTrue(MimeMessage msg) throws MessagingException {
        msg.setFlag(Flags.Flag.SEEN, true);
    }

    /**
     * 判断邮件是否需要阅读回执
     *
     * @param msg 邮件内容
     * @return 需要回执返回true, 否则返回false
     * @throws MessagingException
     */
    public boolean isReplySign(MimeMessage msg) throws MessagingException {
        boolean replySign = false;
        String[] headers = msg.getHeader("Disposition-Notification-To");
        if (headers != null)
            replySign = true;
        return replySign;
    }

    /**
     * 获得邮件的优先级
     *
     * @param msg 邮件内容
     * @return 1(High):紧急  3:普通(Normal)  5:低(Low)
     * @throws MessagingException
     */
    public String getPriority(MimeMessage msg) throws MessagingException {
        String priority = "普通";
        String[] headers = msg.getHeader("X-Priority");
        if (headers != null) {
            String headerPriority = headers[0];
            if (headerPriority.indexOf("1") != -1 || headerPriority.indexOf("High") != -1)
                priority = "紧急";
            else if (headerPriority.indexOf("5") != -1 || headerPriority.indexOf("Low") != -1)
                priority = "低";
            else
                priority = "普通";
        }
        return priority;
    }

    /**
     * 获得邮件文本内容
     *
     * @param part    邮件体
     * @param content 存储邮件文本内容的字符串
     * @throws MessagingException
     * @throws IOException
     */
    public void getMailTextContent(Part part, StringBuffer content) throws MessagingException, IOException {
        //如果是文本类型的附件，通过getContent方法可以取到文本内容，但这不是我们需要的结果，所以在这里要做判断
        boolean isContainTextAttach = part.getContentType().indexOf("name") > 0;
        if (part.isMimeType("text/*") && !isContainTextAttach) {
            content.append(part.getContent().toString());
        } else if (part.isMimeType("message/rfc822")) {
            getMailTextContent((Part) part.getContent(), content);
        } else if (part.isMimeType("multipart/*")) {
            Multipart multipart = (Multipart) part.getContent();
            int partCount = multipart.getCount();
            for (int i = 0; i < partCount; i++) {
                BodyPart bodyPart = multipart.getBodyPart(i);
                getMailTextContent(bodyPart, content);
            }
        }
    }

    /**
     * 保存附件
     *
     * @param part    邮件中多个组合体中的其中一个组合体
     * @param destDir 附件保存目录
     * @throws UnsupportedEncodingException
     * @throws MessagingException
     * @throws FileNotFoundException
     * @throws IOException
     */
    public void saveAttachment(Part part, String destDir) throws MessagingException, IOException {
        if (part.isMimeType("multipart/*")) {
            Multipart multipart = (Multipart) part.getContent();    //复杂体邮件
            //复杂体邮件包含多个邮件体
            int partCount = multipart.getCount();
            for (int i = 0; i < partCount; i++) {
                //获得复杂体邮件中其中一个邮件体
                BodyPart bodyPart = multipart.getBodyPart(i);
                //某一个邮件体也有可能是由多个邮件体组成的复杂体
                String disp = bodyPart.getDisposition();
                if (disp != null && (disp.equalsIgnoreCase(Part.ATTACHMENT) || disp.equalsIgnoreCase(Part.INLINE))) {
                    InputStream is = bodyPart.getInputStream();
                    saveFile(is, destDir, decodeText(bodyPart.getFileName()));
                } else if (bodyPart.isMimeType("multipart/*")) {
                    saveAttachment(bodyPart, destDir);
                } else {
                    String contentType = bodyPart.getContentType();
                    if (contentType.indexOf("name") != -1 || contentType.indexOf("application") != -1) {
                        saveFile(bodyPart.getInputStream(), destDir, decodeText(bodyPart.getFileName()));
                    }
                }
            }
        } else if (part.isMimeType("message/rfc822")) {
            saveAttachment((Part) part.getContent(), destDir);
        }
    }

    /**
     * 读取输入流中的数据保存至指定目录
     *
     * @param is       输入流
     * @param fileName 文件名
     * @param destDir  文件存储目录
     * @throws FileNotFoundException
     * @throws IOException
     */
    private void saveFile(InputStream is, String destDir, String fileName) throws FileNotFoundException, IOException {
        BufferedInputStream bis = new BufferedInputStream(is);
        BufferedOutputStream bos = new BufferedOutputStream(
                new FileOutputStream(new File(destDir + fileName)));
        int len = -1;
        while ((len = bis.read()) != -1) {
            bos.write(len);
            bos.flush();
        }
        bos.close();
        bis.close();
    }

    /**
     * 文本解码
     *
     * @param encodeText 解码MimeUtility.encodeText(String text)方法编码后的文本
     * @return 解码后的文本
     * @throws UnsupportedEncodingException
     */
    public String decodeText(String encodeText) throws UnsupportedEncodingException {
        if (encodeText == null || "".equals(encodeText)) {
            return "";
        } else {
            return MimeUtility.decodeText(encodeText);
        }
    }

    /**
     * 执行命令通过软件解压rld/rwd文件到D:\out\new\下
     */
    public void systemCommand() {
        try {
            Runtime runtime = Runtime.getRuntime();
            File file = new File("D:\\in\\");
            //遍历所有文件
            File[] files = file.listFiles();
            if (null == files || files.length == 0) {
                log.warn("路径：{} 下为空，没有要解析的文件");
                return;
            }
            Map<String, WindTowerInfo> windTowerInfoMap = windTowerInfoService.list().stream().collect(Collectors.toMap(x -> x.getEquipmentNo() + "", x -> x, (x1, x2) -> x1));
            Map<String, EmailWindTowerInfo> emailWindTowerInfoMap = emailWindTowerInfoService.list().stream().collect(Collectors.toMap(x -> x.getEquipmentNo() + "", x -> x, (x1, x2) -> x1));
            for (File f : files) {
                try {
                    //文件类型，做解析区分使用
                    String fileTypeStr = "";

                    String fileEquipmentNo = "";
                    String fileType = f.getName().split("\\.")[1];
                    if (fileType.equals("RWD")) {
                        //RWD文件类型
                        fileEquipmentNo = f.getName().substring(0, 4);
                    } else {
                        //rld文件类型
                        fileEquipmentNo = f.getName().split("_")[0];
                    }
                    WindTowerInfo windTowerInfo = windTowerInfoMap.get(fileEquipmentNo);
                    //没有这个编号的塔
                    if (null == windTowerInfo) {
                        EmailWindTowerInfo emailWindTowerInfo = emailWindTowerInfoMap.get(fileEquipmentNo);
                        if (null == emailWindTowerInfo) {
                            //如果测风塔里面没有这个塔并且邮件测风塔里也没有这个塔 则添加到邮箱读取的测风塔表中
                            EmailWindTowerInfo emailWindTowerInfoNew = new EmailWindTowerInfo();
                            emailWindTowerInfoNew.setEquipmentNo(fileEquipmentNo);
                            emailWindTowerInfoService.save(emailWindTowerInfoNew);
                            log.info(fileEquipmentNo + " 测风塔信息里没有这个的塔 并且邮件测风塔里也没有这个塔");
                        } else {
                            log.info(fileEquipmentNo + " 测风塔信息里没有这个的塔 邮件测风塔里已存在这个塔");
                        }
                    } else {
                        if (fileType.equals("RWD")) {
                            //RWD文件类型
                            if (windTowerInfo.getPassword().equals("")) {
                                log.error("该测风塔没有配置密码");
                                return;
                            } else {
                                String password = windTowerInfo.getPassword();
                                String cmd = "\"D:\\NRG\\SymDR\\SDR.exe\"" + " /z " + password + " " + f.getPath();
                                Process ipconfig = runtime.exec(cmd);
                                ipconfig.waitFor();
                                InputStream inputStream = ipconfig.getInputStream();
                                byte[] bytes = new byte[1024];
                                int len = 0;
                                while ((len = inputStream.read(bytes)) != -1) {
                                    log.info("解析RWD文件完成：{}", new String(bytes, 0, len, "GBK"));
                                }

                                //转换成txt的文件在D:\NRG\ScaledData\目录下 移动到 D:\out\下   转换文件后会有两个文件一个txt  一个log  删除log 移动txt
                                File file1 = new File("D:\\NRG\\ScaledData\\");
                                File[] files1 = file1.listFiles();
                                for (File e : files1) {
                                    String[] name = e.getName().split("\\.");
                                    if (name[1].equals("txt")) {
                                        FileUtil.move(e.getPath(), outPutDir);
                                    } else {
                                        e.delete();
                                    }
                                }
                                //转成txt后把文件移动到系统文件备份目录下
                                File file2 = new File("D:\\in\\");
                                File[] files2 = file2.listFiles();
                                //xls移动系统文件目录下
                                for (File e : files2) {
                                    String[] str = e.getName().split("\\.");
                                    if (str[1].equals("RWD")) {
                                        FileUtil.move(e.getPath(), FileUtil.getSystemFilePath() + File.separator + str[0].substring(0, 4));
                                    } else {
                                        String[] strs = str[0].split("_");
                                        FileUtil.move(e.getPath(), FileUtil.getSystemFilePath() + File.separator + strs[0]);
                                    }
                                }
                                //把txt文件转成excel文件并解析
                                fileTypeStr = "RWD";
                            }
                        } else {
                            //rld文件类型
                            if ("".equals(windTowerInfo.getPassword())) {
                                log.error(windTowerInfo.getEquipmentNo() + "测风塔没有配置数据密码");
                                return;
                            } else {
                                String[] s = new String[]{
                                        "\"D:\\Program Files (x86)\\Renewable NRG Systems\\SymPRO Desktop\\SymPRODesktop.exe\"",
                                        "/cmd", "convert", "/file", f.getPath(),
                                        "/pass", windTowerInfo.getPassword(), "/type", "\"meas\"", "/outputdir", "\"D:\\out\\new\""
                                };
                                Process ipconfig = runtime.exec(s);
                                ipconfig.waitFor();
                                InputStream inputStream = ipconfig.getInputStream();
                                byte[] bytes = new byte[1024];
                                int len = 0;
                                while ((len = inputStream.read(bytes)) != -1) {
                                    log.info("解析RLD文件完成：{}", new String(bytes, 0, len, "GBK"));
                                }
                            }
                            //转成txt后把文件移动到系统文件备份目录下
                            File file1 = new File("D:\\in\\");
                            File[] files1 = file1.listFiles();
                            //xls移动系统文件目录下
                            for (File e : files1) {
                                String[] str = e.getName().split("\\.");
                                if (str[1].equals("RWD")) {
                                    FileUtil.move(e.getPath(), FileUtil.getSystemFilePath() + File.separator + str[0].substring(0, 4));
                                } else {
                                    String[] strs = str[0].split("_");
                                    FileUtil.move(e.getPath(), FileUtil.getSystemFilePath() + File.separator + strs[0]);
                                }
                            }
                            //把txt文件转成excel文件并解析
                            fileTypeStr = "rld";
                        }

                    }
                    analysisDataService.analysisData(fileTypeStr);
                } catch (Exception e) {
                    log.error("处理文件：{} 异常：{}", file.getAbsolutePath(), e);
                }
            }


        } catch (
                Exception e) {
            log.error("执行系统命令失败:{}", e);
        }
    }
}