bytesailing-mail/src/main/java/com/fjhx/email/service/impl/MailServiceImpl.java

package com.fjhx.email.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.fjhx.email.config.base.BaseEntity;
import com.fjhx.email.config.exception.ServiceException;
import com.fjhx.email.entity.*;
import com.fjhx.email.entity.dto.GetMessagePageDto;
import com.fjhx.email.entity.dto.MailFolderInfo;
import com.fjhx.email.entity.dto.MailboxInfo;
import com.fjhx.email.entity.dto.SetSeenDto;
import com.fjhx.email.entity.vo.MessageDetailVo;
import com.fjhx.email.entity.vo.MessageVo;
import com.fjhx.email.mapper.EnterpriseMessageMapper;
import com.fjhx.email.mapper.MailMapper;
import com.fjhx.email.mapper.PersonalMessageMapper;
import com.fjhx.email.service.*;
import com.fjhx.email.utils.ObsFileUtil;
import com.fjhx.email.utils.PageWrapper;
import com.fjhx.email.utils.email.ImapUtil;
import com.fjhx.email.utils.email.MessageAddress;
import com.fjhx.email.utils.email.TextAndAttachment;
import com.sun.mail.imap.IMAPFolder;
import com.sun.mail.imap.IMAPMessage;
import com.sun.mail.imap.IMAPStore;
import lombok.SneakyThrows;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.PlatformTransactionManager;
import org.springframework.transaction.TransactionDefinition;
import org.springframework.transaction.TransactionStatus;

import javax.mail.*;
import java.io.IOException;
import java.io.InputStream;
import java.util.*;
import java.util.concurrent.*;
import java.util.function.Function;
import java.util.stream.Collectors;

@Slf4j
@Service
public class MailServiceImpl implements IMailService {

    /**
     * 创建一个线程池
     */
    private static final Executor executor = new ThreadPoolExecutor(
            12,
            36,
            60,
            TimeUnit.SECONDS,
            new ArrayBlockingQueue<>(36),
            new ThreadPoolExecutor.CallerRunsPolicy()
    );

    @Autowired
    private MailMapper mailMapper;
    @Autowired
    private IPersonalMessageService personalMessageService;
    @Autowired
    private IEnterpriseMessageService enterpriseMessageService;
    @Autowired
    private IEnterpriseMessageAddressService enterpriseMessageAddressService;
    @Autowired
    private IEnterpriseMessageAttachmentService enterpriseMessageAttachmentService;
    @Autowired
    private IEnterpriseMessageContentService enterpriseMessageContentService;
    @Autowired
    private IPersonalMessageAddressService personalMessageAddressService;
    @Autowired
    private IPersonalMessageAttachmentService personalMessageAttachmentService;
    @Autowired
    private IPersonalMessageContentService personalMessageContentService;
    @Autowired
    private IPersonalMailboxService personalMailboxService;
    @Autowired
    private IEnterpriseMailboxService enterpriseMailboxService;
    @Autowired
    private IEnterpriseDomainService enterpriseDomainService;
    @Autowired
    private TransactionDefinition transactionDefinition;
    @Autowired
    private PlatformTransactionManager platformTransactionManager;
    @Autowired
    private IPersonalFolderService personalFolderService;
    @Autowired
    private IEnterpriseFolderService enterpriseFolderService;
    @Autowired
    private EnterpriseMessageMapper enterpriseMessageMapper;
    @Autowired
    private PersonalMessageMapper personalMessageMapper;

    @Override
    public List<MailboxInfo> getMailboxInfoListByUserId(List<Long> userIdList, Integer mailType) {
        if (ObjectUtil.isEmpty(userIdList)) {
            return Collections.emptyList();
        }
        return mailMapper.getMailboxInfoListByUserId(userIdList, mailType);
    }

    @SneakyThrows
    @Override
    public PageWrapper<MessageVo> getMessagePage(GetMessagePageDto dto) {

        PageWrapper<MessageVo> pageWrapper;
//        IMAPStore imapStore;
//        IMAPFolder folder;

        // 个人邮箱
        if (dto.getType().equals(1)) {
            QueryWrapper<PersonalMessage> wrapper = Wrappers.query();
            wrapper.eq("pm.folder_id", dto.getFolderId());
            wrapper.and(ObjectUtil.isNotEmpty(dto.getKeyword()), q1 -> q1
                    .like("pm.from_email", dto.getKeyword())
                    .or().like("pm.from_personal_name", dto.getKeyword())
                    .or().like("pm.subject", dto.getKeyword())
                    .or().like("pmc.content", dto.getKeyword())
            );
            wrapper.orderByDesc("pm.send_date");
            Page<PersonalMessage> page = personalMessageMapper.getPage(dto.getPage(), wrapper);
//            Page<PersonalMessage> page = personalMessageService.page(dto, q -> q
//                    .eq(PersonalMessage::getFolderId, dto.getFolderId())
//                    .orderByDesc(PersonalMessage::getSendDate)
//            );

            pageWrapper = new PageWrapper<>(page, MessageVo.class);

            if (page.getSize() == 0) {
                return pageWrapper;
            }

            PersonalFolder personalFolder = personalFolderService.getById(dto.getFolderId());
            if (personalFolder == null) {
                throw new ServiceException("文件夹已被删除");
            }

//            MailboxInfo mailboxInfo = getMailboxInfo(1, personalFolder.getMailboxId());
//            imapStore = ImapUtil.getStore(
//                    mailboxInfo.getReceiveHost(),
//                    mailboxInfo.getMailUser(),
//                    mailboxInfo.getMailPassword()
//            );
//            folder = (IMAPFolder) imapStore.getFolder(personalFolder.getName());
        }

        // 企业邮箱
        else {
            QueryWrapper<EnterpriseMessage> wrapper = Wrappers.query();
            wrapper.eq("em.folder_id", dto.getFolderId());
            wrapper.and(ObjectUtil.isNotEmpty(dto.getKeyword()), q1 -> q1
                    .like("em.from_email", dto.getKeyword())
                    .or().like("em.from_personal_name", dto.getKeyword())
                    .or().like("em.subject", dto.getKeyword())
                    .or().like("emc.content", dto.getKeyword())
            );
            wrapper.orderByDesc("em.send_date");
            Page<EnterpriseMessage> page = enterpriseMessageMapper.getPage(dto.getPage(), wrapper);
//            Page<EnterpriseMessage> page = enterpriseMessageService.page(dto, q -> q
//                    .eq(EnterpriseMessage::getFolderId, dto.getFolderId())
//                    .orderByDesc(EnterpriseMessage::getSendDate)
//            );

            pageWrapper = new PageWrapper<>(page, MessageVo.class);

            if (page.getSize() == 0) {
                return pageWrapper;
            }

            EnterpriseFolder enterpriseFolder = enterpriseFolderService.getById(dto.getFolderId());
            if (enterpriseFolder == null) {
                throw new ServiceException("文件夹已被删除");
            }

//            MailboxInfo mailboxInfo = getMailboxInfo(2, enterpriseFolder.getMailboxId());
//            imapStore = ImapUtil.getStore(
//                    mailboxInfo.getReceiveHost(),
//                    mailboxInfo.getMailUser(),
//                    mailboxInfo.getMailPassword()
//            );
//            folder = (IMAPFolder) imapStore.getFolder(enterpriseFolder.getName());
        }

//        folder.open(Folder.READ_ONLY);

//        ArrayList<CompletableFuture<Void>> futureList = new ArrayList<>();
//        for (MessageVo messageVo : pageWrapper.getRows()) {
//            CompletableFuture<Void> completableFuture = CompletableFuture.runAsync(() -> {
//                Long uid = messageVo.getUid();
//                try {
//                    Message message = folder.getMessageByUID(uid);
//                    if (message != null) {
//                        String flags = ImapUtil.getFlags(message.getFlags());
//                        messageVo.setFlags(flags);
//                    }
//                } catch (MessagingException e) {
//                    throw new ServiceException("获取邮件是否已读失败");
//                }
//            }, executor);
//            futureList.add(completableFuture);
//        }
//
//        futureList.forEach(CompletableFuture::join);
//
//        ImapUtil.closeFolder(folder);
//        ImapUtil.closeStore(imapStore);

        return pageWrapper;
    }

    @SneakyThrows
    @Override
    public MessageDetailVo getMessageDetail(GetMessagePageDto dto) {
        Long messageId = dto.getMessageId();
        Integer type = dto.getType();

        Long mailboxId;
        Integer syncStatus;
        String folderName;
        Long uid;

        //发件人地址
        String fromEmail;

        if (type.equals(1)) {
            PersonalMessage personalMessage = personalMessageService.getById(messageId);
            if (personalMessage == null) {
                throw new ServiceException("没有找到邮箱");
            }

            fromEmail = personalMessage.getFromEmail();

            mailboxId = personalMessage.getMailboxId();
            syncStatus = personalMessage.getSyncStatus();
            folderName = personalMessage.getFolderName();
            uid = personalMessage.getUid();
        } else {
            EnterpriseMessage enterpriseMessage = enterpriseMessageService.getById(messageId);
            if (enterpriseMessage == null) {
                throw new ServiceException("没有找到邮箱");
            }

            fromEmail = enterpriseMessage.getFromEmail();

            mailboxId = enterpriseMessage.getMailboxId();
            syncStatus = enterpriseMessage.getSyncStatus();
            folderName = enterpriseMessage.getFolderName();
            uid = enterpriseMessage.getUid();
        }


        //设置已读
        CompletableFuture.runAsync(() -> {
            MailboxInfo mailboxInfo = getMailboxInfo(type, mailboxId);
            IMAPStore store = null;
            IMAPFolder folder = null;
            try {
                store = ImapUtil.getStore(
                        mailboxInfo.getReceiveHost(),
                        mailboxInfo.getMailUser(),
                        mailboxInfo.getMailPassword()
                );
                folder = (IMAPFolder) store.getFolder(folderName);
                folder.open(Folder.READ_WRITE);
                IMAPMessage message = (IMAPMessage) folder.getMessageByUID(uid);

                if (message == null) {
                    return;
                }

                // 设置已读
                ImapUtil.setSeen(message);
                String flags = ImapUtil.getFlags(message.getFlags());
                if (type.equals(1)) {
                    PersonalMessage personalMessage = personalMessageService.getById(messageId);
                    if (personalMessage != null) {
                        personalMessage.setFlags(flags);
                        personalMessageService.updateById(personalMessage);
                    }
                } else {
                    EnterpriseMessage enterpriseMessage = enterpriseMessageService.getById(messageId);
                    if (enterpriseMessage != null) {
                        enterpriseMessage.setFlags(flags);
                        enterpriseMessageService.updateById(enterpriseMessage);
                    }
                }
            } catch (Exception e) {
                log.error("修改已读异常" + e.getMessage());
            } finally {
                try {
                    ImapUtil.closeFolder(folder);
                    ImapUtil.closeStore(store);
                } catch (Exception e) {
                    log.error("关闭链接失败");
                }
            }
        });

        MessageDetailVo messageDetailVo = new MessageDetailVo();
        messageDetailVo.setMessageId(messageId);
        messageDetailVo.setFromEmail(fromEmail);

        // 已同步
        if (syncStatus.equals(1)) {

            if (type.equals(1)) {
                setPersonalMessageDetailVo(messageDetailVo, messageId);
            } else {
                setEnterpriseMessageDetailVo(messageDetailVo, messageId);
            }

        }

        // 未同步
        else {

            MailboxInfo mailboxInfo = getMailboxInfo(type, mailboxId);

            IMAPStore store = ImapUtil.getStore(
                    mailboxInfo.getReceiveHost(),
                    mailboxInfo.getMailUser(),
                    mailboxInfo.getMailPassword()
            );

            IMAPFolder folder = (IMAPFolder) store.getFolder(folderName);

            folder.open(Folder.READ_WRITE);

            IMAPMessage message = (IMAPMessage) folder.getMessageByUID(uid);

            if (message == null) {
                throw new ServiceException("没有找到邮件详情，此邮件可能已被删除");
            }

            // 赋值邮件 正文、附件
            CompletableFuture<Void> setTextAndAttachmentFuture = CompletableFuture.runAsync(() -> {
                try {
                    setTextAndAttachment(message, messageDetailVo);
                } catch (Exception e) {
                    throw new ServiceException("邮件加载失败");
                }
            }, executor);

            // 赋值邮件 收件人、抄送人、密送人、回复人
            CompletableFuture<Void> setAddressFuture = CompletableFuture.runAsync(() -> {
                try {
                    setAddress(message, messageDetailVo);
                } catch (MessagingException e) {
                    throw new ServiceException("邮件加载失败");
                }
            }, executor);

            // 设置已读
            CompletableFuture<Void> setSeenFuture = CompletableFuture.runAsync(() -> {
                try {
                    ImapUtil.setSeen(message);
                } catch (MessagingException e) {
                    throw new ServiceException("邮件加载失败");
                }
            }, executor);

            // 保存数据
            setSeenFuture.join();
            setAddressFuture.join();
            setTextAndAttachmentFuture.join();

            // 保存内容
            executor.execute(() -> {

                // 关闭连接
                try {
                    ImapUtil.closeFolder(folder);
                    ImapUtil.closeStore(store);
                } catch (Exception e) {
                    log.error("关闭链接失败");
                }

                saveMessageDetail(messageId, messageDetailVo, type);

            });

        }

        // copy一份数据，防止多线程下把文件路径前缀保存到数据库中
        MessageDetailVo copy = JSONObject.parseObject(JSONObject.toJSONString(messageDetailVo), MessageDetailVo.class);

        for (MessageDetailVo.MessageAttachment messageAttachment : copy.getMessageAttachmentList()) {
            messageAttachment.setUrl(ObsFileUtil.getCompleteUrl(messageAttachment.getUrl()));
        }

        return copy;
    }

    @SneakyThrows
    @Override
    public void setUnreadMessageCount(List<MailboxInfo> mailboxInfoList) {

        List<Long> mailboxInfoIds = mailboxInfoList.stream().map(MailboxInfo::getId).collect(Collectors.toList());
        List<MessageVo> unreadMessageCount = mailMapper.getUnreadMessageCount(Wrappers.query()
                .in("m.mailbox_id", mailboxInfoIds)
        );
        Map<Long, MessageVo> unreadMessageCountMap = unreadMessageCount.stream().collect(Collectors.toMap(MessageVo::getFolderId, Function.identity()));


        for (MailboxInfo mailboxInfo : mailboxInfoList) {

            for (MailFolderInfo mailFolderInfo : mailboxInfo.getMailFolderInfoList()) {
                MessageVo messageVo = unreadMessageCountMap.get(mailFolderInfo.getId());
                int count = ObjectUtil.isEmpty(messageVo) ? 0 : messageVo.getCount();
                mailFolderInfo.setUnreadMessageCount(count);
            }

//            IMAPStore store = ImapUtil.getStore(
//                    mailboxInfo.getReceiveHost(),
//                    mailboxInfo.getMailUser(),
//                    mailboxInfo.getMailPassword()
//            );
//
//            for (MailFolderInfo mailFolderInfo : mailboxInfo.getMailFolderInfoList()) {
//                String name = mailFolderInfo.getName();
//                if (StrUtil.equalsAnyIgnoreCase(name, "inbox")) {
//                    IMAPFolder folder = (IMAPFolder) store.getFolder(name);
//                    folder.open(Folder.READ_WRITE);
//                    int unreadMessageCount = folder.getUnreadMessageCount();
//                    mailFolderInfo.setUnreadMessageCount(unreadMessageCount);
//                    ImapUtil.closeFolder(folder);
//                    break;
//                }
//            }
//
//            ImapUtil.closeStore(store);

//            if (Objects.equals(mailboxInfo.getType(), 1)) {
//                //个人邮箱
//                Map<Long, List<PersonalMessage>> personalMessageMap = personalMessageService.mapKGroup(PersonalMessage::getFolderId, q -> q
//                        .eq(PersonalMessage::getMailboxId, mailboxInfo.getId())
//                        .and(q1 -> q1
//                                .isNull(PersonalMessage::getFlags)
//                                .or().eq(PersonalMessage::getFlags, "")
//                        )
//                );
//                MessageVo messageVo = unreadMessageCountMap.get(mailboxInfo.getId());
//                for (MailFolderInfo mailFolderInfo : mailboxInfo.getMailFolderInfoList()) {
//                    List<PersonalMessage> personalMessages = personalMessageMap.getOrDefault(mailFolderInfo.getId(), new ArrayList<>());
//                    mailFolderInfo.setUnreadMessageCount(personalMessages.size());
//                }
//            } else {
//                //企业邮箱
//                Map<Long, List<EnterpriseMessage>> enterpriseMessageMap = enterpriseMessageService.mapKGroup(EnterpriseMessage::getFolderId, q -> q
//                        .eq(EnterpriseMessage::getMailboxId, mailboxInfo.getId())
//                        .and(q1 -> q1
//                                .isNull(EnterpriseMessage::getFlags)
//                                .or().eq(EnterpriseMessage::getFlags, "")
//                        )
//                );
//                for (MailFolderInfo mailFolderInfo : mailboxInfo.getMailFolderInfoList()) {
//                    List<EnterpriseMessage> personalMessages = enterpriseMessageMap.getOrDefault(mailFolderInfo.getId(), new ArrayList<>());
//                    mailFolderInfo.setUnreadMessageCount(personalMessages.size());
//                }
//            }
        }

    }

    @Override
    public void setSeen(String host, String user, String password, SetSeenDto dto) throws MessagingException {
        IMAPStore store = ImapUtil.getStore(host, user, password);
        IMAPFolder folder = (IMAPFolder) store.getFolder(dto.getFolderName());
        folder.open(Folder.READ_WRITE);

        List<Long> uidList = dto.getUidList();

        long[] uids = new long[uidList.size()];
        for (int i = 0; i < uidList.size(); i++) {
            uids[i] = uidList.get(i);
        }

        Message[] messages = folder.getMessagesByUID(uids);

        for (Message message : messages) {
            Flags flags = message.getFlags();
            flags.add(Flags.Flag.SEEN);
            message.setFlags(flags, true);

            long uid = folder.getUID(message);
            if (dto.getType() == 1) {
                //个人邮箱
                personalMessageService.update(q -> q
                        .eq(PersonalMessage::getUid, uid)
                        .set(PersonalMessage::getFlags, ImapUtil.getFlags(flags))
                );
            } else {
                //企业邮箱
                enterpriseMessageService.update(q -> q
                        .eq(EnterpriseMessage::getUid, uid)
                        .set(EnterpriseMessage::getFlags, ImapUtil.getFlags(flags))
                );
            }
        }


//        Flags flags = new Flags();
//        flags.add(Flags.Flag.SEEN);
//
//        folder.setFlags(messages, flags, true);
//
//        if(dto.getType()==1){
//            //个人邮箱
//            personalMessageService.update(q->q
//                    .in(PersonalMessage::getUid,uids)
//                    .set(PersonalMessage::getFlags, ImapUtil.getFlags(flags))
//            );
//        }else{
//            //企业邮箱
//            enterpriseMessageService.update(q->q
//                    .in(EnterpriseMessage::getUid,uids)
//                    .set(EnterpriseMessage::getFlags, ImapUtil.getFlags(flags))
//            );
//        }
    }

    @Override
    public void cancelSeen(String host, String user, String password, SetSeenDto dto) throws MessagingException {
        IMAPStore store = ImapUtil.getStore(host, user, password);
        IMAPFolder folder = (IMAPFolder) store.getFolder(dto.getFolderName());
        folder.open(Folder.READ_WRITE);

        List<Long> uidList = dto.getUidList();

        long[] uids = new long[uidList.size()];
        for (int i = 0; i < uidList.size(); i++) {
            uids[i] = uidList.get(i);
        }

        Message[] messages = folder.getMessagesByUID(uids);

        for (Message message : messages) {
            Flags flags = message.getFlags();
            flags.remove(Flags.Flag.SEEN);
            message.setFlags(flags, true);

            long uid = folder.getUID(message);
            if (dto.getType() == 1) {
                //个人邮箱
                personalMessageService.update(q -> q
                        .eq(PersonalMessage::getUid, uid)
                        .set(PersonalMessage::getFlags, ImapUtil.getFlags(flags))
                );
            } else {
                //企业邮箱
                enterpriseMessageService.update(q -> q
                        .eq(EnterpriseMessage::getUid, uid)
                        .set(EnterpriseMessage::getFlags, ImapUtil.getFlags(flags))
                );
            }
        }
    }

    /**
     * 保存内容
     */
    private void saveMessageDetail(Long messageId, MessageDetailVo messageDetailVo, Integer type) {

        TransactionStatus transactionStatus = platformTransactionManager.getTransaction(transactionDefinition);

        try {
            if (type == 1) {

                PersonalMessageContent personalMessageContent = new PersonalMessageContent();
                personalMessageContent.setMessageId(messageId);
                personalMessageContent.setContent(messageDetailVo.getContent());
                personalMessageContent.setMimeType(messageDetailVo.getMimeType());
                personalMessageContentService.save(personalMessageContent);

                List<MessageDetailVo.MessageAddress> messageAddressList = messageDetailVo.getMessageAddressList();
                List<PersonalMessageAddress> personalMessageContentService = messageAddressList.stream().map(item -> {
                    PersonalMessageAddress personalMessageAddress = new PersonalMessageAddress();
                    personalMessageAddress.setMessageId(messageId);
                    personalMessageAddress.setPersonalName(item.getPersonalName());
                    personalMessageAddress.setType(item.getType());
                    personalMessageAddress.setEmail(item.getEmail());
                    return personalMessageAddress;
                }).collect(Collectors.toList());
                personalMessageAddressService.saveBatch(personalMessageContentService);

                List<MessageDetailVo.MessageAttachment> messageAttachmentList = messageDetailVo.getMessageAttachmentList();
                List<PersonalMessageAttachment> messageAttachments = messageAttachmentList.stream().map(item -> {
                    PersonalMessageAttachment personalMessageAttachment = new PersonalMessageAttachment();
                    personalMessageAttachment.setName(item.getName());
                    personalMessageAttachment.setUrl(item.getUrl());
                    personalMessageAttachment.setMessageId(messageId);
                    return personalMessageAttachment;
                }).collect(Collectors.toList());
                personalMessageAttachmentService.saveBatch(messageAttachments);

                personalMessageService.update(q -> q
                        .eq(PersonalMessage::getId, messageId)
                        .set(PersonalMessage::getSyncStatus, 1)
                        .set(BaseEntity::getUpdateTime, new Date())
                );

            } else {

                EnterpriseMessageContent enterpriseMessageContent = new EnterpriseMessageContent();
                enterpriseMessageContent.setMessageId(messageId);
                enterpriseMessageContent.setContent(messageDetailVo.getContent());
                enterpriseMessageContent.setMimeType(messageDetailVo.getMimeType());
                enterpriseMessageContentService.save(enterpriseMessageContent);

                List<MessageDetailVo.MessageAddress> messageAddressList = messageDetailVo.getMessageAddressList();
                List<EnterpriseMessageAddress> enterpriseMessageAddressList = messageAddressList.stream().map(item -> {
                    EnterpriseMessageAddress enterpriseMessageAddress = new EnterpriseMessageAddress();
                    enterpriseMessageAddress.setMessageId(messageId);
                    enterpriseMessageAddress.setPersonalName(item.getPersonalName());
                    enterpriseMessageAddress.setType(item.getType());
                    enterpriseMessageAddress.setEmail(item.getEmail());
                    return enterpriseMessageAddress;
                }).collect(Collectors.toList());
                enterpriseMessageAddressService.saveBatch(enterpriseMessageAddressList);

                List<MessageDetailVo.MessageAttachment> messageAttachmentList = messageDetailVo.getMessageAttachmentList();
                List<EnterpriseMessageAttachment> messageAttachments = messageAttachmentList.stream().map(item -> {
                    EnterpriseMessageAttachment enterpriseMessageAttachment = new EnterpriseMessageAttachment();
                    enterpriseMessageAttachment.setName(item.getName());
                    enterpriseMessageAttachment.setUrl(item.getUrl());
                    enterpriseMessageAttachment.setMessageId(messageId);
                    return enterpriseMessageAttachment;
                }).collect(Collectors.toList());
                enterpriseMessageAttachmentService.saveBatch(messageAttachments);

                enterpriseMessageService.update(q -> q
                        .eq(EnterpriseMessage::getId, messageId)
                        .set(EnterpriseMessage::getSyncStatus, 1)
                        .set(BaseEntity::getUpdateTime, new Date())
                );

            }

            // 提交事务
            platformTransactionManager.commit(transactionStatus);
        } catch (Exception e) {
            // 回滚事务
            platformTransactionManager.rollback(transactionStatus);
        }

    }

    private MailboxInfo getMailboxInfo(Integer type, Long mailboxId) {
        MailboxInfo mailboxInfo = new MailboxInfo();

        if (type.equals(1)) {
            PersonalMailbox personalMailbox = personalMailboxService.getById(mailboxId);
            mailboxInfo.setReceiveHost(personalMailbox.getReceiveHost());
            mailboxInfo.setReceivePort(personalMailbox.getReceivePort());
            mailboxInfo.setMailUser(personalMailbox.getMailUser());
            mailboxInfo.setMailPassword(personalMailbox.getMailPassword());

            return mailboxInfo;
        }

        EnterpriseMailbox enterpriseMailbox = enterpriseMailboxService.getById(mailboxId);
        EnterpriseDomain enterpriseDomain = enterpriseDomainService.getById(enterpriseMailbox.getDomainId());
        mailboxInfo.setReceiveHost(enterpriseDomain.getReceiveHost());
        mailboxInfo.setReceivePort(enterpriseDomain.getReceivePort());
        mailboxInfo.setMailUser(enterpriseMailbox.getMailUserPrefix() + "@" + enterpriseDomain.getDomainName());
        mailboxInfo.setMailPassword(enterpriseMailbox.getMailPassword());
        return mailboxInfo;
    }

    /**
     * 保存个人邮件明细
     */
    private void setPersonalMessageDetailVo(MessageDetailVo vo, Long messageId) {
        List<PersonalMessageAddress> addressList = personalMessageAddressService.list(
                q -> q.eq(PersonalMessageAddress::getMessageId, messageId));
        vo.setMessageAddressList(BeanUtil.copyToList(addressList, MessageDetailVo.MessageAddress.class));

        List<PersonalMessageAttachment> attachmentList = personalMessageAttachmentService.list(
                q -> q.eq(PersonalMessageAttachment::getMessageId, messageId));
        vo.setMessageAttachmentList(BeanUtil.copyToList(attachmentList, MessageDetailVo.MessageAttachment.class));

        PersonalMessageContent content = personalMessageContentService.getOne(
                q -> q.eq(PersonalMessageContent::getMessageId, messageId));
        vo.setContent(content.getContent());
    }

    /**
     * 保存企业邮件明细
     */
    private void setEnterpriseMessageDetailVo(MessageDetailVo vo, Long messageId) {
        List<EnterpriseMessageAddress> addressList = enterpriseMessageAddressService.list(
                q -> q.eq(EnterpriseMessageAddress::getMessageId, messageId));
        vo.setMessageAddressList(BeanUtil.copyToList(addressList, MessageDetailVo.MessageAddress.class));

        List<EnterpriseMessageAttachment> attachmentList = enterpriseMessageAttachmentService.list(
                q -> q.eq(EnterpriseMessageAttachment::getMessageId, messageId));
        vo.setMessageAttachmentList(BeanUtil.copyToList(attachmentList, MessageDetailVo.MessageAttachment.class));

        EnterpriseMessageContent content = enterpriseMessageContentService.getOne(
                q -> q.eq(EnterpriseMessageContent::getMessageId, messageId));
        vo.setContent(content.getContent());
    }

    /**
     * 获取邮件 收件人、抄送人、密送人、回复人
     */
    private void setAddress(IMAPMessage message, MessageDetailVo messageDetailVo) throws MessagingException {

        List<MessageAddress> messageAddressList = ImapUtil.getMessageAddressList(message);

        List<MessageDetailVo.MessageAddress> list = messageAddressList
                .stream()
                .map(item -> {
                    MessageDetailVo.MessageAddress messageAddress = new MessageDetailVo.MessageAddress();
                    messageAddress.setType(item.getType());
                    messageAddress.setEmail(item.getEmail());
                    messageAddress.setPersonalName(item.getName());
                    return messageAddress;
                })
                .collect(Collectors.toList());

        messageDetailVo.setMessageAddressList(list);
    }

    /**
     * 获取邮件正文以及附件
     */
    private void setTextAndAttachment(IMAPMessage message, MessageDetailVo vo) throws MessagingException, IOException {

        List<CompletableFuture<Void>> futureList = new ArrayList<>();

        List<MessageDetailVo.MessageAttachment> attachmentList = new ArrayList<>();

        ImapUtil.setTextAndAttachment(message, new TextAndAttachment() {

            @Override
            public void setPlain(String plain) {
                if (ObjectUtil.notEqual(vo.getMimeType(), "text/html")) {
                    vo.setContent(plain);
                    vo.setMimeType("text/plain");
                }
            }

            @Override
            public void setHtml(String html) {
                vo.setContent(html);
                vo.setMimeType("text/html");
            }

            @Override
            public void setAttachment(String fileName, InputStream is) {

                CompletableFuture<Void> future = CompletableFuture.runAsync(() -> {

                    String url = ObsFileUtil.uploadFile(fileName, is);
                    MessageDetailVo.MessageAttachment messageAttachment = new MessageDetailVo.MessageAttachment();
                    messageAttachment.setUrl(url);
                    messageAttachment.setName(fileName);
                    attachmentList.add(messageAttachment);

                }, executor);

                futureList.add(future);

            }

            @Override
            public void unknown(Part part) throws MessagingException {
                log.error("id为 {} 的邮件存在未知类型：{}", vo.getMessageId(), part.getContentType());
            }

        });

        futureList.forEach(CompletableFuture::join);
        vo.setMessageAttachmentList(attachmentList);

    }

}