eta_email_analysis/services/pcsg/fix.go

package pcsg

import (
	"encoding/json"
	"errors"
	"eta/eta_email_analysis/global"
	"eta/eta_email_analysis/models/eta"
	"eta/eta_email_analysis/models/report"
	"eta/eta_email_analysis/utils"
	"eta/eta_email_analysis/utils/mail"
	"fmt"
	"github.com/emersion/go-imap"
	"github.com/emersion/go-imap/client"
	"log"
	"strings"
)

func FixEmailBaseInfo() {
	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, true)
	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
	}

	to := mbox.Messages // 此文件下的邮件总数

	err = mail.ListenMailV2(c, to)
	if err != nil {
		fmt.Println("处理失败：", err)
	}

}

func FixHistory() {
	list, err := report.GetMailOutsideReport()
	if err != nil {
		fmt.Println("获取没有分类的信息失败：", err)
		return
	}

	ruleJson, err := eta.GetBusinessConfByKey("MailCheckRule")
	if err != nil {
		global.FILE_LOG.Error("获取规则配置失败：%v", err)
		return
	}
	var ruleList []report.MailRule
	err = json.Unmarshal([]byte(ruleJson.ConfVal), &ruleList)
	if err != nil {
		global.FILE_LOG.Error("解析规则配置失败：%v", err)
		return
	}
	ruleMap := make(map[string]report.MailRule)
	for _, v := range ruleList {
		ruleMap[v.Rule] = v
	}

	classifyAll, e := report.GetClassifyAll()
	if e != nil {
		err = e
		global.FILE_LOG.Error("获取分类失败：", err)
		return
	}
	calssifyMap := make(map[int]*report.Classify)
	for _, v := range classifyAll {
		calssifyMap[v.Id] = v
	}

	for _, reportInfo := range list {
		for _, v := range ruleList {
			title := strings.ToLower(reportInfo.Title)
			rule := strings.ToLower(v.Rule)
			if strings.Contains(title, rule) {
				fmt.Println(reportInfo.Title, "匹配到规则：", v.Rule)
				reportInfo.Title = v.Title
				reportInfo.Abstract = v.Abstract
				reportInfo.ClassifyID = v.ClassifyId
				if calssifyMap[v.ClassifyId] != nil {
					reportInfo.ClassifyName = calssifyMap[v.ClassifyId].ClassifyName
				}
				// 特殊规则
				if strings.Contains(title, "海外分公司市场信息月报") || strings.Contains(title, "区域市场信息月报") {
					if reportInfo.SysUserName == "report.pcanalyst00@petrochina-usa.com" {
						v.Author = "PCI"
					} else {
						v.Author = reportInfo.SysUserName
					}
				}
				if strings.Contains(v.Author, "@") {
					sysUser, tmpErr := eta.GetSysUserByEmail(v.Author)
					if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
						err = tmpErr
						return
					}
					if sysUser.AdminId > 0 {
						reportInfo.SysUserID = sysUser.AdminId
						reportInfo.SysUserName = sysUser.RealName
					} else {
						reportInfo.SysUserName = v.Author
					}
				} else {
					reportInfo.SysUserName = v.Author
				}
				err = reportInfo.Update([]string{"Title", "Abstract", "ClassifyID", "ClassifyName", "SysUserID", "SysUserName"})
				if err != nil {
					fmt.Println("更新失败：", err)
					return
				}
				fmt.Println(reportInfo.Title, "更新成功")
				break
			}
		}
		if strings.Contains(reportInfo.Title, "[PCI ANALYTICS CLOUD PLATFORM(00) Fwd] - ") {
			reportInfo.Title = strings.Replace(reportInfo.Title, "[PCI ANALYTICS CLOUD PLATFORM(00) Fwd] - ", "", -1)
			err = reportInfo.Update([]string{"Title"})
			if err != nil {
				fmt.Println("更新失败：", err)
				return
			}
			fmt.Println(reportInfo.Title, "去除前缀成功")
		}
	}
}

func FixHistory2() {
	list, err := report.GetMailOutsideReportHistory()
	if err != nil {
		fmt.Println("获取没有分类的信息失败：", err)
		return
	}
	fmt.Println("报告数量：", len(list))
	ruleJson, err := eta.GetBusinessConfByKey("MailCheckRule")
	if err != nil {
		global.FILE_LOG.Error("获取规则配置失败：%v", err)
		return
	}
	var ruleList []report.MailRule
	err = json.Unmarshal([]byte(ruleJson.ConfVal), &ruleList)
	if err != nil {
		global.FILE_LOG.Error("解析规则配置失败：%v", err)
		return
	}
	fmt.Println("规则数量：", len(ruleList))

	for _, reportInfo := range list {
		fmt.Println("标题：", reportInfo.Title)
		fmt.Println("作者：", reportInfo.SysUserName)
		// 特殊规则
		if strings.Contains(reportInfo.Title, "海外分公司市场信息月报") || strings.Contains(reportInfo.Title, "区域市场信息月报") {
			if reportInfo.SysUserName == "report.pcanalyst00@petrochina-usa.com" {
				reportInfo.SysUserName = "PCI"
				err = reportInfo.Update([]string{"SysUserName"})
				if err != nil {
					fmt.Println("更新失败：", err)
					return
				}
				fmt.Println(reportInfo.Title, "更新成功")
				continue
			} else if strings.Contains(reportInfo.SysUserName, "@") {
				sysUser, tmpErr := eta.GetSysUserByEmail(reportInfo.SysUserName)
				if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
					err = tmpErr
					return
				}
				if sysUser.AdminId > 0 {
					fmt.Println(reportInfo.SysUserName, " 有对应用户:", sysUser.RealName)
					reportInfo.SysUserID = sysUser.AdminId
					reportInfo.SysUserName = sysUser.RealName
				}
				fmt.Println("无对应用户")
				err = reportInfo.Update([]string{"SysUserID", "SysUserName"})
				if err != nil {
					fmt.Println("更新失败：", err)
					return
				}
				fmt.Println(reportInfo.Title, "更新成功")
			}
		}
	}
}

func FixHistory3() {
	list, err := report.GetMailOutsideReportHistory2()
	if err != nil {
		fmt.Println("获取没有分类的信息失败：", err)
		return
	}

	ruleJson, err := eta.GetBusinessConfByKey("MailCheckRule")
	if err != nil {
		global.FILE_LOG.Error("获取规则配置失败：%v", err)
		return
	}
	var ruleList []report.MailRule
	err = json.Unmarshal([]byte(ruleJson.ConfVal), &ruleList)
	if err != nil {
		global.FILE_LOG.Error("解析规则配置失败：%v", err)
		return
	}
	ruleMap := make(map[string]report.MailRule)
	for _, v := range ruleList {
		ruleMap[v.Rule] = v
	}

	classifyAll, e := report.GetClassifyAll()
	if e != nil {
		err = e
		global.FILE_LOG.Error("获取分类失败：", err)
		return
	}
	calssifyMap := make(map[int]*report.Classify)
	for _, v := range classifyAll {
		calssifyMap[v.Id] = v
	}

	for _, reportInfo := range list {
		for _, v := range ruleList {
			title := strings.ToLower(reportInfo.Title)
			rule := strings.ToLower(v.Rule)
			if strings.Contains(title, rule) {
				fmt.Println(reportInfo.Title, "匹配到规则：", v.Rule)
				reportInfo.Title = v.Title
				reportInfo.Abstract = v.Abstract
				reportInfo.ClassifyID = v.ClassifyId
				if calssifyMap[v.ClassifyId] != nil {
					reportInfo.ClassifyName = calssifyMap[v.ClassifyId].ClassifyName
				}
				// 特殊规则
				if reportInfo.ClassifyID == 377 || reportInfo.ClassifyID == 378 {
					if reportInfo.SysUserName == "report.pcanalyst00@petrochina-usa.com" {
						v.Author = "PCI"
					} else {
						v.Author = reportInfo.SysUserName
					}
				}
				if strings.Contains(v.Author, "@") {
					sysUser, tmpErr := eta.GetSysUserByEmail(v.Author)
					if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
						err = tmpErr
						return
					}
					if sysUser.AdminId > 0 {
						reportInfo.SysUserID = sysUser.AdminId
						reportInfo.SysUserName = sysUser.RealName
					} else {
						reportInfo.SysUserName = v.Author
					}
				} else {
					reportInfo.SysUserName = v.Author
				}
				err = reportInfo.Update([]string{"Title", "Abstract", "SysUserID", "SysUserName"})
				if err != nil {
					fmt.Println("更新失败：", err)
					return
				}
				fmt.Println(reportInfo.Title, "更新成功")
				break
			}
		}
		if strings.Contains(reportInfo.Title, "[PCI ANALYTICS CLOUD PLATFORM(00) Fwd] - ") {
			reportInfo.Title = strings.Replace(reportInfo.Title, "[PCI ANALYTICS CLOUD PLATFORM(00) Fwd] - ", "", -1)
			err = reportInfo.Update([]string{"Title"})
			if err != nil {
				fmt.Println("更新失败：", err)
				return
			}
			fmt.Println(reportInfo.Title, "去除前缀成功")
		}
	}
}

func FixHistory1226() {
	list, err := report.GetMailOutsideReportHistory3()
	if err != nil {
		fmt.Println("获取没有分类的信息失败：", err)
		return
	}

	ruleJson, err := eta.GetBusinessConfByKey("MailCheckRule")
	if err != nil {
		global.FILE_LOG.Error("获取规则配置失败：%v", err)
		return
	}
	var ruleList []report.MailRule
	err = json.Unmarshal([]byte(ruleJson.ConfVal), &ruleList)
	if err != nil {
		global.FILE_LOG.Error("解析规则配置失败：%v", err)
		return
	}
	ruleMap := make(map[string]report.MailRule)
	for _, v := range ruleList {
		ruleMap[v.Rule] = v
	}

	classifyAll, e := report.GetClassifyAll()
	if e != nil {
		err = e
		global.FILE_LOG.Error("获取分类失败：", err)
		return
	}
	calssifyMap := make(map[int]*report.Classify)
	for _, v := range classifyAll {
		calssifyMap[v.Id] = v
	}

	for _, reportInfo := range list {
		for _, v := range ruleList {
			title := strings.ToLower(reportInfo.Title)
			rule := strings.ToLower(v.Rule)
			if strings.Contains(title, rule) {
				fmt.Println(reportInfo.Title, "匹配到规则：", v.Rule)
				reportInfo.Title = v.Title
				reportInfo.Abstract = v.Abstract
				reportInfo.ClassifyID = v.ClassifyId
				if calssifyMap[v.ClassifyId] != nil {
					reportInfo.ClassifyName = calssifyMap[v.ClassifyId].ClassifyName
				}
				// 特殊规则
				if strings.Contains(title, "海外分公司市场信息月报") || strings.Contains(title, "区域市场信息月报") {
					if reportInfo.SysUserName == "report.pcanalyst00@petrochina-usa.com" {
						v.Author = "PCI"
					} else {
						v.Author = reportInfo.SysUserName
					}
				}
				if strings.Contains(v.Author, "@") {
					sysUser, tmpErr := eta.GetSysUserByEmail(v.Author)
					if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
						err = tmpErr
						return
					}
					if sysUser.AdminId > 0 {
						reportInfo.SysUserID = sysUser.AdminId
						reportInfo.SysUserName = sysUser.RealName
					} else {
						reportInfo.SysUserName = v.Author
					}
				} else {
					reportInfo.SysUserName = v.Author
				}
				err = reportInfo.Update([]string{"Title", "Abstract", "ClassifyID", "ClassifyName", "SysUserID", "SysUserName"})
				if err != nil {
					fmt.Println("更新失败：", err)
					return
				}
				fmt.Println(reportInfo.Title, "更新成功")
				break
			}
		}
		if strings.Contains(reportInfo.Title, "[PCI ANALYTICS CLOUD PLATFORM(00) Fwd] - ") {
			reportInfo.Title = strings.Replace(reportInfo.Title, "[PCI ANALYTICS CLOUD PLATFORM(00) Fwd] - ", "", -1)
			err = reportInfo.Update([]string{"Title"})
			if err != nil {
				fmt.Println("更新失败：", err)
				return
			}
			fmt.Println(reportInfo.Title, "去除前缀成功")
		}
	}
}

func FixUserName() {
	var condition string
	var pars []interface{}
	idList := []int{409, 398, 395, 406, 411, 404, 402, 397, 410, 403, 407, 391, 392, 393, 394, 390, 388, 389, 396, 399, 400, 401, 405, 408, 415, 416}
	condition += " AND classify_id IN ? "
	pars = append(pars, idList)

	list, err := report.GetOutsideReportListByCondition(condition, pars)
	if err != nil {
		fmt.Println("获取报告失败：", err)
		return
	}

	obj := report.OutsideEmailBaseInfo{}
	for _, v := range list {
		// 没有id就忽略
		if v.EmailMessageUID <= 0 {
			continue
		}
		emailMessage, err := obj.GetByEmailMessageIdAndFolder(uint32(v.EmailMessageUID), "INBOX")
		if err != nil {
			fmt.Println("查找邮件失败：", err)
			continue
		}

		title := emailMessage.Title
		var abstract string
		var classifyId int
		var classifyName string
		var sysUserId int
		var sysUserName string

		sysUserName = emailMessage.FromAddress
		// 查找用户
		if emailMessage.From != `` {
			tmpEmailStrList := strings.Split(sysUserName, "<")
			if len(tmpEmailStrList) >= 2 {
				sysUserName = tmpEmailStrList[1]
				tmpEmailStrList = strings.Split(sysUserName, ">")
				if len(tmpEmailStrList) >= 2 {
					sysUserName = tmpEmailStrList[0]
				}
			}
			sysUser, tmpErr := eta.GetSysUserByEmail(sysUserName)
			if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
				err = tmpErr
				return
			}
			if tmpErr == nil {
				sysUserId = sysUser.AdminId
				sysUserName = sysUser.RealName
			}
		}
		title = strings.Replace(title, "[PCI ANALYTICS CLOUD PLATFORM(00) Fwd] - ", "", -1)

		for _, ruleInfo := range ruleList {
			tmpTitle := strings.ToLower(emailMessage.Title)
			rule := strings.ToLower(ruleInfo.Rule)
			if strings.Contains(tmpTitle, rule) {
				title = ruleInfo.Title
				abstract = ruleInfo.Abstract
				classifyId = ruleInfo.ClassifyId
				classify, e := report.GetClassifyByClassifyId(ruleInfo.ClassifyId)
				if e != nil {
					err = e
					global.FILE_LOG.Error("获取分类失败：", err)
					return
				}
				classifyName = classify.ClassifyName

				// 特殊规则
				//if strings.Contains(title, "海外分公司市场信息月报") || strings.Contains(title, "区域市场信息月报") {
				//	if emailMessage.From == "report.pcanalyst00@petrochina-usa.com" {
				//		sysUserName = "PCI"
				//		break
				//	} else {
				//		v.Author = emailMessage.From
				//	}
				//}

				if ruleInfo.Author != `` {
					if strings.Contains(ruleInfo.Author, "@") {
						sysUser, tmpErr := eta.GetSysUserByEmail(ruleInfo.Author)
						if tmpErr != nil && !utils.IsErrNoRow(tmpErr) {
							err = tmpErr
							return
						}
						if sysUser.AdminId > 0 {
							sysUserId = sysUser.AdminId
							sysUserName = sysUser.RealName
						} else {
							sysUserName = ruleInfo.Author
						}
					} else {
						sysUserName = ruleInfo.Author
					}
				}

				break
			}
		}

		updateCols := make([]string, 0)
		if v.SysUserID != sysUserId {
			v.SysUserID = sysUserId
			updateCols = append(updateCols, "sys_user_id")
		}
		if v.SysUserName != sysUserName {
			v.SysUserName = sysUserName
			updateCols = append(updateCols, "sys_user_name")
		}
		if v.Abstract != abstract {
			v.Abstract = abstract
			updateCols = append(updateCols, "abstract")
		}
		if v.ClassifyID != classifyId {
			v.ClassifyID = classifyId
			updateCols = append(updateCols, "classify_id")
		}
		if v.ClassifyName != classifyName {
			v.ClassifyName = classifyName
			updateCols = append(updateCols, "classify_name")
		}

		if len(updateCols) > 0 {
			err = v.Update(updateCols)
			if err != nil {
				fmt.Println(v.OutsideReportID, "更新失败：", err)
			}
		}
	}

	fmt.Println("修复完成")
}