新增邮件同步任务和修复功能- 在配置中添加邮件开始读取序号和同步时间配置项

- 实现邮件同步任务，支持自定义同步时间
- 添加邮件修复功能，用于更新缺少用户信息的邮件报告
- 优化邮件读取逻辑，支持多种字符集解码

config/config.go

@@ -97,6 +97,8 @@ type Email struct {
 	Password                        string   `mapstructure:"password" json:"password" yaml:"password" description:"邮件服务器密码"`
 	Folder                          string   `mapstructure:"folder" json:"folder" yaml:"folder" description:"邮件服务器文件夹"`
 	ReadBatchSize                   int      `mapstructure:"read-batch-size" json:"read-batch-size" yaml:"read-batch-size" description:"邮件读取批次"`
+	StartReadIndex                  int      `mapstructure:"start-read-index" json:"start-read-index" yaml:"start-read-index" description:"邮件开始读取的序号"`
+	SyncEmailTime                   string   `mapstructure:"sync-email-time" json:"sync-email-time" yaml:"sync-email-time" description:"邮件同步时间"`
 	IgnoreEmail                     []string `mapstructure:"ignore-email" json:"ignore-email" yaml:"ignore-email" description:"邮件过滤，不读取这些邮箱"`
 	IgnoreEmailCaseSensitive        []string `mapstructure:"ignore-email-case-sensitive" json:"ignore-email-case-sensitive" yaml:"ignore-email-case-sensitive" description:"邮件过滤，不读取这些邮箱，大小写敏感"`
 	IgnoreEmailAddress              []string `mapstructure:"ignore-email-address" json:"ignore-email-address" yaml:"ignore-email-address" description:"邮件过滤，不读取这些邮箱，大小写敏感"`

go.mod

@@ -23,7 +23,7 @@ require (
 	github.com/swaggo/swag v1.16.1
 	github.com/tealeg/xlsx v1.0.5
 	golang.org/x/image v0.9.0
-	golang.org/x/text v0.17.0
+	golang.org/x/text v0.18.0
 	gorm.io/driver/mysql v1.5.1
 	gorm.io/gorm v1.25.2
 )

go.sum

@@ -679,6 +679,8 @@ golang.org/x/text v0.13.0 h1:ablQoSUd0tRdKxZewP80B+BaqeKJuVhuRxj/dkrun3k=
 golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
 golang.org/x/text v0.17.0 h1:XtiM5bkSOt+ewxlOE/aE/AKEHibwj/6gvWMl9Rsh0Qc=
 golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+golang.org/x/text v0.18.0 h1:XvMDiNzPAl0jr17s6W9lcaIhGUfUORdGCNsuLmPG224=
+golang.org/x/text v0.18.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
 golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
 golang.org/x/time v0.0.0-20191024005414-555d28b269f0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=

init_serve/task.go

@@ -24,7 +24,16 @@ func InitTask() {
 	//	}
 	//}
 
-	pcsg.ListenMail()
+	{
+		syncTime := global.CONFIG.Email.SyncEmailTime
+		if syncTime == `` {
+			syncTime = `0 */30 * * * *`
+		}
+		_, err := c.AddFunc(syncTime, pcsg.ListenMail)
+		if err != nil {
+			global.LOG.Error("pcsg.ListenMail err" + err.Error())
+		}
+	}
 
 	c.Start()
 }

models/report/outside_report.go

@@ -122,6 +122,22 @@ func CreateOutsideReport(item *OutsideReport, outsideReportAttachmentList []*Out
 // @return maxEmailMessageUid
 // @return err
 func GetMaxOutsideReportByEmailMessageId() (maxEmailMessageUid int, err error) {
-	err = global.DEFAULT_MYSQL.Model(OutsideReport{}).Select("max(outside_report_id)").Scan(&maxEmailMessageUid).Error
+	err = global.DEFAULT_MYSQL.Model(OutsideReport{}).Select("max(email_message_uid)").Scan(&maxEmailMessageUid).Error
+	return
+}
+
+// GetNoSysUserNameOutsideReport
+// @Description: 获取没有用户的信息
+// @return items
+// @return err
+func GetNoSysUserNameOutsideReport() (items []*OutsideReport, err error) {
+	err = global.DEFAULT_MYSQL.Where("sys_user_name = '' AND source = 3 ").Find(&items).Error
+
+	return
+}
+
+func (m *OutsideReport) Update(cols []string) (err error) {
+	err = global.DEFAULT_MYSQL.Select(cols).Updates(m).Error
+
 	return
 }

services/pcsg/fix.go

@@ -0,0 +1,93 @@
+package pcsg
+
+import (
+	"errors"
+	"eta/eta_email_analysis/global"
+	"eta/eta_email_analysis/models/report"
+	"eta/eta_email_analysis/utils/mail"
+	"fmt"
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-imap/client"
+	"log"
+)
+
+func Fix() {
+	mailAddress := fmt.Sprintf("%s:%d", global.CONFIG.Email.Host, global.CONFIG.Email.Port)
+
+	// 建立与 IMAP 服务器的连接
+	c, err := client.DialTLS(mailAddress, nil)
+	if err != nil {
+		fmt.Printf("连接 IMAP 服务器失败: %+v \n", err)
+		return
+	}
+	// 最后一定不要忘记退出登录
+	defer func() {
+		_ = c.Logout()
+	}()
+
+	// 登录
+	if err = c.Login(global.CONFIG.Email.UserName, global.CONFIG.Email.Password); err != nil {
+		fmt.Printf("邮箱[%s] 登录失败: %v \n", fmt.Sprintf("%s:%s", global.CONFIG.Email.UserName, mailAddress), err)
+		return
+	}
+	// 列出当前邮箱中的文件夹
+	mailboxes := make(chan *imap.MailboxInfo, 10)
+	done := make(chan error, 1) // 记录错误的 chan
+	go func() {
+		done <- c.List("", "*", mailboxes)
+	}()
+	log.Println("-->当前邮箱的文件夹 Mailboxes:")
+
+	var folderExists bool
+	for m := range mailboxes {
+		log.Println("* ", m.Name)
+		if m.Name == global.CONFIG.Email.Folder {
+			folderExists = true
+		}
+	}
+
+	err = <-done
+	if err != nil {
+		global.LOG.Errorf("列出邮箱列表时，出现错误：%v \n", err)
+		return
+	}
+
+	log.Println("-->列出邮箱列表完毕！")
+	if !folderExists {
+		err = errors.New(fmt.Sprintf("文件夹[%s] 不存在 \n", global.CONFIG.Email.Folder))
+		return
+	}
+
+	// 选择指定的文件夹
+	mbox, err := c.Select(global.CONFIG.Email.Folder, false)
+	if err != nil {
+		err = errors.New(fmt.Sprintf("选择邮件箱失败: %+v", err))
+		return
+	}
+	//log.Printf("mbox %+v \n", mbox)
+	log.Printf("当前文件夹[%s]中，总共有 %d 封邮件 \n", global.CONFIG.Email.Folder, mbox.Messages)
+	if mbox.Messages == 0 {
+		//log.Fatalf("当前文件夹[%s]中没有邮件", folder)
+		return
+	}
+
+	list, err := report.GetNoSysUserNameOutsideReport()
+	if err != nil {
+		fmt.Println("获取没有用户的信息失败：", err)
+		return
+	}
+
+	for _, v := range list {
+		_, fromName, tmpErr := mail.ListenMailV2(c, v.EmailMessageUID)
+		if tmpErr != nil {
+			fmt.Println(v.Title, ",获取失败:", tmpErr)
+			continue
+		}
+		v.SysUserName = fromName
+		tmpErr = v.Update([]string{"SysUserName"})
+		if tmpErr != nil {
+			fmt.Println(v.Title, ",更新信息失败:", tmpErr)
+			continue
+		}
+	}
+}

services/pcsg/mail.go

@@ -21,7 +21,15 @@ import (
 // 同步用户锁，防止重复同步，不管是全量还是增量，都是同一时间只能一个同步
 var lockListenEmail sync.Mutex
 
-func ListenMail() (err error) {
+func ListenMail() {
+	var err error
+	defer func() {
+		if err != nil {
+			global.FILE_LOG.Errorf("监听邮件失败：%s", err.Error())
+		}
+	}()
+	//Fix()
+	//return
 	lockListenEmail.Lock()
 	// 目录创建
 	_ = ensureDirExists(fmt.Sprintf("%s%s", global.CONFIG.Serve.StaticDir, `file`))
@@ -36,10 +44,13 @@ func ListenMail() (err error) {
 
 	fmt.Println("开始监听邮件")
 
-	emailMessageUID, err := report.GetMaxOutsideReportByEmailMessageId()
+	emailMessageUID := global.CONFIG.Email.StartReadIndex
-	// 已经存在了，那么就返回
+	if emailMessageUID <= 0 {
-	if err != nil {
+		emailMessageUID, err = report.GetMaxOutsideReportByEmailMessageId()
-		global.FILE_LOG.Errorf("获取已入库的最大邮件id失败：%s", err.Error())
+		// 已经存在了，那么就返回
+		if err != nil {
+			global.FILE_LOG.Errorf("获取已入库的最大邮件id失败：%s", err.Error())
+		}
 	}
 
 	mailAddress := fmt.Sprintf("%s:%d", global.CONFIG.Email.Host, global.CONFIG.Email.Port)
@@ -97,7 +108,7 @@ func handleMailMessage(emailMessage mail.MailMessage) (err error) {
 	outReport, err := report.GetOutsideReportByEmailMessageId(emailMessageUID)
 	// 已经存在了，那么就返回
 	if err == nil {
-		global.FILE_LOG.Debugf("已存在，就不处理了,报告标题：%s", outReport.Title)
+		global.FILE_LOG.Debugf("已存在，就不处理了,报告标题：%s；；邮件下标：%d", outReport.Title, emailMessage.Uid)
 		return
 	}
 	fmt.Println("开始处理邮件，标题：", emailMessage.Title, "；邮件下标：", emailMessage.Uid)
@@ -165,7 +176,7 @@ func handleMailMessage(emailMessage mail.MailMessage) (err error) {
 	//}
 
 	var sysUserId int
-	sysUserName := emailMessage.FromEmail
+	sysUserName := emailMessage.FromAddress
 	// 查找用户
 	if emailMessage.From != `` {
 		tmpEmailStrList := strings.Split(sysUserName, "<")

utils/mail/charset_reader.go

@@ -3,6 +3,7 @@ package mail
 import (
 	"fmt"
 	"golang.org/x/text/encoding/charmap"
+	"golang.org/x/text/encoding/japanese"
 	"golang.org/x/text/encoding/simplifiedchinese"
 	"golang.org/x/text/transform"
 	"io"
@@ -53,6 +54,9 @@ var charsetMap = map[string]transform.Transformer{
 	"windows-1257":   charmap.Windows1257.NewDecoder(),
 	"windows-1258":   charmap.Windows1258.NewDecoder(),
 	"x-user-defined": charmap.XUserDefined.NewDecoder(),
+	"euc-jp":         japanese.EUCJP.NewDecoder(),
+	"iso-2022-jp":    japanese.ISO2022JP.NewDecoder(),
+	"shift_jis":      japanese.ShiftJIS.NewDecoder(),
 }
 
 // 定义一个自定义的 CharsetReader 函数，它能够处理 gb2312 和 gbk 字符集

utils/mail/fix.go

@@ -0,0 +1,89 @@
+package mail
+
+import (
+	"errors"
+	"eta/eta_email_analysis/global"
+	"fmt"
+	"github.com/emersion/go-imap"
+	"github.com/emersion/go-imap/client"
+	"github.com/emersion/go-message/mail"
+	"log"
+	"strings"
+)
+
+func ListenMailV2(c *client.Client, index int) (fromAddress, fromName string, err error) { // 收件箱
+	// 创建一个序列集，用于批量读取邮件
+	seqSet := new(imap.SeqSet)
+	seqSet.AddRange(uint32(index), uint32(index)) // 添加指定范围内的邮件编号
+
+	// 获取整个消息正文
+	// imap.FetchEnvelope：请求获取邮件的信封数据（例如发件人、收件人、主题等元数据）。
+	// imap.FetchRFC822：请求获取完整的邮件内容，包括所有头部和正文。
+	items := []imap.FetchItem{imap.FetchFlags, imap.FetchEnvelope, imap.FetchRFC822}
+
+	// 获取邮件内容 Start
+	messages := make(chan *imap.Message, 5) // 创建一个通道，用于接收邮件消息
+	fetchDone := make(chan error, 1)        // 创建一个通道，用于接收错误消息
+	go func() {
+		// Fetch方法用于从服务器获取邮件数据，这里请求了邮件的信封和完整内容
+		fetchDone <- c.Fetch(seqSet, items, messages)
+	}()
+
+	err = <-fetchDone
+	if err != nil {
+		global.LOG.Errorf("获取邮件信息出现错误：%v \n", err)
+		return
+	}
+	// 获取邮件内容 End
+
+	//log.Println("开始读取邮件内容")
+	for msg := range messages {
+		return readEveryMsgV2(msg)
+	}
+
+	return
+}
+
+// document link: https://github.com/emersion/go-imap/wiki/Fetching-messages
+func readEveryMsgV2(msg *imap.Message) (fromAddress, fromName string, err error) {
+	// 获取邮件正文
+	r := msg.GetBody(&imap.BodySectionName{})
+	if r == nil {
+		global.FILE_LOG.Info("服务器没有返回消息内容")
+	}
+
+	mr, err := mail.CreateReader(r)
+	if err != nil {
+		//log.Fatalf("邮件读取时出现错误： %v \n", err)
+		err = errors.New(fmt.Sprintf("邮件读取时出现错误：%v \n", err))
+		return
+	}
+
+	// 发件人
+	{
+		fromStr := mr.Header.Get("From")
+		//fmt.Println(fromStr)
+		// 处理无效地址的情况
+		if !strings.Contains(fromStr, "@") {
+			fromStr = strings.TrimSpace(fromStr)
+			fromStr = strings.TrimPrefix(fromStr, `"`)
+			fromStr = strings.TrimSuffix(fromStr, `"`)
+			//fmt.Println(fromStr)
+			fromAddress = fromStr
+			fromName = fromStr
+		} else {
+			from, tmpErr := mr.Header.AddressList("From")
+			if tmpErr != nil {
+				log.Println("发件人 异常:", err.Error())
+			}
+			if len(from) > 0 {
+				fromAddress = from[0].Address
+				fromName = from[0].Name
+				//mailMessage.From = from[0].String()
+				//log.Println("发件人 From:", from)
+			}
+		}
+	}
+
+	return
+}

utils/mail/imap.go

@@ -19,14 +19,14 @@ import (
 )
 
 type MailMessage struct {
-	Date       time.Time         `description:"收件时间"`
+	Date        time.Time         `description:"收件时间"`
-	Uid        uint32            `description:"该邮件在邮箱中的唯一id"`
+	Uid         uint32            `description:"该邮件在邮箱中的唯一id"`
-	FromEmail  string            `description:"发件人邮箱"`
+	FromAddress string            `description:"发件人邮箱"`
-	From       string            `description:"发件人名称"`
+	From        string            `description:"发件人名称"`
-	Title      string            `description:"邮件标题"`
+	Title       string            `description:"邮件标题"`
-	Content    string            `description:"邮件主体正文"`
+	Content     string            `description:"邮件主体正文"`
-	Resources  map[string]string `description:"正文内嵌资源"`
+	Resources   map[string]string `description:"正文内嵌资源"`
-	Attachment map[string]string `description:"附件资源"`
+	Attachment  map[string]string `description:"附件资源"`
 }
 
 func ListenMail(mailAddress, folder, userName, password string, readBatchSize, fromEmailIndex int, mailMessageChan chan MailMessage, mailMessageDoneChan chan bool) (err error) { // 收件箱
@@ -114,6 +114,7 @@ func ListenMail(mailAddress, folder, userName, password string, readBatchSize, f
 			from = to - maxNum + 1
 		}
 	}
+	//from = 310
 
 	step := uint32(5)
 	for i := from; i <= to; {
@@ -160,14 +161,16 @@ func ListenMail(mailAddress, folder, userName, password string, readBatchSize, f
 						os.Remove(v)
 					}
 				}
-				global.FILE_LOG.Fatalf("读取邮件内容时出现错误：%v \n", tmpErr)
+				global.FILE_LOG.Errorf("读取邮件内容时出现错误：%v \n", tmpErr)
 				continue
 			}
-			// 如果取到了，那么写入待处理chan
+			// 如果没有取到，那么就过滤
-			if isRead {
+			if !isRead {
-				// 写入邮件处理chan
+				continue
-				mailMessageChan <- emailMessage
 			}
+			// 如果取到了，那么写入待处理chan
+			// 写入邮件处理chan
+			mailMessageChan <- emailMessage
 		}
 
 		//time.Sleep(time.Second * 5) // 休眠10秒
@@ -180,119 +183,6 @@ func ListenMail(mailAddress, folder, userName, password string, readBatchSize, f
 	return
 }
 
-//func ListenMail(mailAddress, folder, userName, password string, readBatchSize int, mailMessageChan chan MailMessage, mailMessageDoneChan chan bool) (err error) { // 收件箱
-//	defer func() {
-//		if err != nil {
-//			fmt.Println("err:", err.Error())
-//		}
-//	}()
-//	// 建立与 IMAP 服务器的连接
-//	c, err := client.DialTLS(mailAddress, nil)
-//	if err != nil {
-//		fmt.Printf("连接 IMAP 服务器失败: %+v \n", err)
-//		return
-//	}
-//	// 最后一定不要忘记退出登录
-//	defer func() {
-//		_ = c.Logout()
-//	}()
-//
-//	// 登录
-//	if err = c.Login(userName, password); err != nil {
-//		fmt.Printf("邮箱[%s] 登录失败: %v \n", fmt.Sprintf("%s:%s", userName, mailAddress), err)
-//		return
-//	}
-//	// 列出当前邮箱中的文件夹
-//	mailboxes := make(chan *imap.MailboxInfo, 10)
-//	done := make(chan error, 1) // 记录错误的 chan
-//	go func() {
-//		done <- c.List("", "*", mailboxes)
-//	}()
-//	log.Println("-->当前邮箱的文件夹 Mailboxes:")
-//
-//	var folderExists bool
-//	for m := range mailboxes {
-//		log.Println("* ", m.Name)
-//		if m.Name == folder {
-//			folderExists = true
-//		}
-//	}
-//
-//	if err := <-done; err != nil {
-//		log.Fatalf("列出邮箱列表时，出现错误：%v \n", err)
-//	}
-//	log.Println("-->列出邮箱列表完毕！")
-//	if !folderExists {
-//		err = errors.New(fmt.Sprintf("文件夹[%s] 不存在 \n", folder))
-//		return
-//	}
-//
-//	// 选择指定的文件夹
-//	mbox, err := c.Select(folder, false)
-//	if err != nil {
-//		err = errors.New(fmt.Sprintf("选择邮件箱失败: %+v", err))
-//		return
-//	}
-//	//log.Printf("mbox %+v \n", mbox)
-//	log.Printf("当前文件夹[%s]中，总共有 %d 封邮件 \n", folder, mbox.Messages)
-//	if mbox.Messages == 0 {
-//		//log.Fatalf("当前文件夹[%s]中没有邮件", folder)
-//		return
-//	}
-//
-//	// 创建一个序列集，用于批量读取邮件
-//	seqSet := new(imap.SeqSet)
-//
-//	// 假设需要获取最后4封邮件时
-//	from := uint32(1)
-//	to := mbox.Messages // 此文件下的邮件总数
-//	if mbox.Messages > 2 {
-//		from = mbox.Messages - 1
-//	}
-//	//from = mbox.Messages - 9
-//	//to = mbox.Messages - 9
-//	from = mbox.Messages
-//	to = mbox.Messages
-//	seqSet.AddRange(from, to) // 添加指定范围内的邮件编号
-//
-//
-//
-//	// 获取整个消息正文
-//	// imap.FetchEnvelope：请求获取邮件的信封数据（例如发件人、收件人、主题等元数据）。
-//	// imap.FetchRFC822：请求获取完整的邮件内容，包括所有头部和正文。
-//	items := []imap.FetchItem{imap.FetchFlags, imap.FetchEnvelope, imap.FetchRFC822}
-//
-//	// 获取邮件内容 Start
-//	messages := make(chan *imap.Message, readBatchSize) // 创建一个通道，用于接收邮件消息
-//	fetchDone := make(chan error, 1)                    // 创建一个通道，用于接收错误消息
-//	go func() {
-//		// Fetch方法用于从服务器获取邮件数据，这里请求了邮件的信封和完整内容
-//		fetchDone <- c.Fetch(seqSet, items, messages)
-//	}()
-//
-//	if err := <-fetchDone; err != nil {
-//		log.Fatalf("获取邮件信息出现错误：%v \n", err)
-//	}
-//	// 获取邮件内容 End
-//
-//	log.Println("开始读取邮件内容")
-//	for msg := range messages {
-//		mailMessage, tmpErr := readEveryMsg(msg)
-//		if tmpErr != nil {
-//			global.FILE_LOG.Fatalf("读取邮件内容时出现错误：%v \n", tmpErr)
-//			continue
-//		}
-//		// 写入邮件处理chan
-//		mailMessageChan <-  emailMessage
-//	}
-//
-//	time.Sleep(time.Second * 5) // 休眠10秒
-//
-//	log.Println("读取了所有邮件，完毕！")
-//
-//	return
-//}
-
 // document link: https://github.com/emersion/go-imap/wiki/Fetching-messages
 func readEveryMsg(msg *imap.Message) (emailMessage MailMessage, ok bool, err error) {
 	ok = true
@@ -337,15 +227,23 @@ func readEveryMsg(msg *imap.Message) (emailMessage MailMessage, ok bool, err err
 
 	// 发件人
 	{
-		from, err := mr.Header.AddressList("From")
+		fromStr := mr.Header.Get("From")
-		if err != nil {
+		fmt.Println(fromStr)
-			log.Println("发件人 异常:", err.Error())
+		// 处理无效地址的情况
-		}
+		if !strings.Contains(fromStr, "@") {
-		if len(from) > 0 {
+			emailMessage.FromAddress = fromStr
-			emailMessage.FromEmail = from[0].Address
+			emailMessage.From = fromStr
-			emailMessage.From = from[0].Name
+		} else {
-			//mailMessage.From = from[0].String()
+			from, tmpErr := mr.Header.AddressList("From")
-			//log.Println("发件人 From:", from)
+			if tmpErr != nil {
+				log.Println("发件人 异常:", err.Error())
+			}
+			if len(from) > 0 {
+				emailMessage.FromAddress = from[0].Address
+				emailMessage.From = from[0].Name
+				//mailMessage.From = from[0].String()
+				//log.Println("发件人 From:", from)
+			}
 		}
 	}
 
@@ -479,7 +377,7 @@ func isIgnore(emailMessage MailMessage) bool {
 	lowerFrom := strings.ToLower(emailMessage.From)
 	for _, email := range global.CONFIG.Email.IgnoreEmail {
 		if utils.ContainsWholeWord(lowerFrom, email) {
-			global.FILE_LOG.Infof("发件人包含%s，过滤掉，标题：%s", email, emailMessage.From)
+			global.FILE_LOG.Infof("发件人包含%s，过滤掉，发件人：%s；标题：%s；所属下标：%d", email, emailMessage.From, emailMessage.Title, emailMessage.Uid)
 			return true
 		}
 	}
@@ -487,23 +385,23 @@ func isIgnore(emailMessage MailMessage) bool {
 	// 邮件标题中包含待过滤的字符串（大小写敏感的标题），那么就过滤
 	for _, email := range global.CONFIG.Email.IgnoreEmailCaseSensitive {
 		if utils.ContainsWholeWord(emailMessage.From, email) {
-			global.FILE_LOG.Infof("发件人包含%s，过滤掉，标题：%s", email, emailMessage.From)
+			global.FILE_LOG.Infof("发件人包含%s，过滤掉，发件人：%s；标题：%s；所属下标：%d", email, emailMessage.From, emailMessage.Title, emailMessage.Uid)
 			return true
 		}
 	}
-	// 发件人中包含待过滤的字符串，那么就过滤
+	// 发件人地址中包含待过滤的字符串，那么就过滤
-	lowerFromAddress := strings.ToLower(emailMessage.FromEmail)
+	lowerFromAddress := strings.ToLower(emailMessage.FromAddress)
 	for _, emailAddress := range global.CONFIG.Email.IgnoreEmailAddress {
 		if utils.ContainsWholeWord(lowerFromAddress, emailAddress) {
-			global.FILE_LOG.Infof("发件人邮箱包含%s，过滤掉，标题：%s", emailAddress, emailMessage.FromEmail)
+			global.FILE_LOG.Infof("发件人邮箱包含%s，过滤掉，发件人邮箱地址：%s；标题：%s；所属下标：%d", emailAddress, emailMessage.FromAddress, emailMessage.Title, emailMessage.Uid)
 			return true
 		}
 	}
 
-	// 邮件标题中包含待过滤的字符串（大小写敏感的标题），那么就过滤
+	// 邮件地址中包含待过滤的字符串（大小写敏感的标题），那么就过滤
 	for _, emailAddress := range global.CONFIG.Email.IgnoreEmailAddressCaseSensitive {
-		if utils.ContainsWholeWord(emailMessage.FromEmail, emailAddress) {
+		if utils.ContainsWholeWord(emailMessage.FromAddress, emailAddress) {
-			global.FILE_LOG.Infof("发件人邮箱包含%s，过滤掉，标题：%s", emailAddress, emailMessage.FromEmail)
+			global.FILE_LOG.Infof("发件人邮箱包含%s，过滤掉，发件人邮箱地址：%s；标题：%s；所属下标：%d", emailAddress, emailMessage.FromAddress, emailMessage.Title, emailMessage.Uid)
 			return true
 		}
 	}
@@ -512,7 +410,7 @@ func isIgnore(emailMessage MailMessage) bool {
 	lowerTitle := strings.ToLower(emailMessage.Title)
 	for _, title := range global.CONFIG.Email.IgnoreEmailTitle {
 		if utils.ContainsWholeWord(lowerTitle, title) {
-			global.FILE_LOG.Infof("邮件标题包含%s，过滤掉，标题：%s", title, emailMessage.Title)
+			global.FILE_LOG.Infof("邮件标题包含%s，过滤掉，标题：%s，所属下标：%d", title, emailMessage.Title, emailMessage.Uid)
 			return true
 		}
 	}
@@ -520,7 +418,7 @@ func isIgnore(emailMessage MailMessage) bool {
 	// 邮件标题中包含待过滤的字符串（大小写敏感的标题），那么就过滤
 	for _, title := range global.CONFIG.Email.IgnoreEmailTitleCaseSensitive {
 		if utils.ContainsWholeWord(emailMessage.Title, title) {
-			global.FILE_LOG.Infof("邮件标题包含%s，过滤掉，标题：%s", title, emailMessage.Title)
+			global.FILE_LOG.Infof("邮件标题包含%s，过滤掉，标题：%s，所属下标：%d", title, emailMessage.Title, emailMessage.Uid)
 			return true
 		}
 	}