eta_mini_crm/scheduler/task.go

package scheduler

import (
	"context"
	"eta/eta_mini_crm/models"
	"eta/eta_mini_crm/utils"
	"fmt"
	"time"

	"github.com/beego/beego/v2/task"
)

func InitJob() {
	fmt.Println("消息推送任务开启。。。")
	// 每天凌晨12点10分检测, 发送消息
	tk1 := task.NewTask("SendReminderMsg", "0 10 0 * * *", SendReminderMsg)
	task.AddTask("发送消息提醒", tk1)
	// 每天凌晨12点检测, 修改用户状态
	tk2 := task.NewTask("ModifyUserStatus", "5 0 0 * * *", ModifyUserStatus)
	task.AddTask("定时修改用户状态", tk2)
	task.StartTask()
}

func ModifyUserStatus(ctx context.Context) (err error) {
	defer func() {
		if err := recover(); err != nil {
			utils.ApiLog.Warn("发送提醒消息，定时任务出错，Err: %s", err)
		}
	}()
	curTime := time.Now()
	var pars []interface{}
	condition := ` AND valid_end_time<?`
	pars = append(pars, curTime)
	condition += ` AND status=? `
	pars = append(pars, 2)
	userIds, err := models.GetUserIdListByCondition(condition, pars)
	if err != nil {
		return
	}
	err = models.UpdateUserStatus(condition, pars)
	if err != nil {
		return
	}
	userRecordList := make([]*models.UserChangeRecord, 0)
	for _, v := range userIds {
		record := &models.UserChangeRecord{}
		record.UserId = v
		record.SysUserId = 0
		record.Content = "有效期到期禁用用户"
		record.CreateTime = time.Now()
		userRecordList = append(userRecordList, record)
	}
	err = models.UserChangeRecordMultiInsert(userRecordList)
	if err != nil {
		return
	}
	return
}

func SendReminderMsg(ctx context.Context) (err error) {
	defer func() {
		if err := recover(); err != nil {
			utils.ApiLog.Warn("发送提醒消息，定时任务出错，Err: %s", err)
		}
	}()
	var userPars7 []interface{}
	var userPars15 []interface{}
	var userPars30 []interface{}
	var userPars60 []interface{}
	var msgPars7 []interface{}
	var msgPars15 []interface{}
	var msgPars30 []interface{}
	var msgPars60 []interface{}

	userTime7 := time.Now().AddDate(0, 0, 7)
	userTime15 := time.Now().AddDate(0, 0, 15)
	userTime30 := time.Now().AddDate(0, 0, 30)
	userTime60 := time.Now().AddDate(0, 0, 60)
	msgTime7 := time.Now().AddDate(0, 0, -7)
	msgTime15 := time.Now().AddDate(0, 0, -15)
	msgTime30 := time.Now().AddDate(0, 0, -30)
	msgTime60 := time.Now().AddDate(0, 0, -60)

	userCondition1 := ` AND valid_end_time<? `
	userCondition2 := ` AND valid_end_time<? AND valid_end_time>? `
	msgCondition := ` AND create_time>? `
	userPars7 = append(userPars7, userTime7)
	userPars15 = append(userPars15, userTime15, userTime7)
	userPars30 = append(userPars30, userTime30, userTime15)
	userPars60 = append(userPars60, userTime60, userTime30)
	msgPars7 = append(msgPars7, msgTime7)
	msgPars15 = append(msgPars15, msgTime15)
	msgPars30 = append(msgPars30, msgTime30)
	msgPars60 = append(msgPars60, msgTime60)

	err = SendMsgToSysUser(userCondition1, msgCondition, userPars7, msgPars7, 7)
	if err != nil {
		utils.ApiLog.Warn("发送提醒消息，定时任务出错，Err: %s", err.Error())
	}
	err = SendMsgToSysUser(userCondition2, msgCondition, userPars15, msgPars15, 15)
	if err != nil {
		utils.ApiLog.Warn("发送提醒消息，定时任务出错，Err: %s", err.Error())
	}
	err = SendMsgToSysUser(userCondition2, msgCondition, userPars30, msgPars30, 30)
	if err != nil {
		utils.ApiLog.Warn("发送提醒消息，定时任务出错，Err: %s", err.Error())
	}
	err = SendMsgToSysUser(userCondition2, msgCondition, userPars60, msgPars60, 60)
	if err != nil {
		utils.ApiLog.Warn("发送提醒消息，定时任务出错，Err: %s", err.Error())
	}
	return
}

func SendMsgToSysUser(userCondition, msgCondition string, userPars, msgPars []interface{}, messagetType int) (err error) {
	total, err := models.GetUserCount(userCondition, userPars)
	if err != nil {
		utils.ApiLog.Warn("获取用户列表失败 task err: %s", err.Error())
	}
	if total == 0 {
		return
	}
	// 获得待发送用户的列表
	userList, err := models.GetUserList(userCondition, userPars, 0, total)
	if err != nil {
		return
	}

	// 获得待通知系统用户的列表
	sysUserIds, err := models.GetSysUserIdList()
	if err != nil {
		return
	}

	messageList, err := models.GetSysMessageReportByCondition(msgCondition, msgPars)
	if err != nil {
		return
	}
	layout := "【%s】到期%d天提醒，请及时跟进"
	messageMap := make(map[int]map[int]struct{})
	for _, v := range messageList {
		if mv, ok := messageMap[v.ReceiveSysUserId]; ok {
			mv[v.UserId] = struct{}{}
		} else {
			messageMap[v.ReceiveSysUserId] = make(map[int]struct{})
			messageMap[v.ReceiveSysUserId][v.UserId] = struct{}{}
		}
	}
	sendMsg := make([]*models.SysMessageReport, 0)
	for _, v := range sysUserIds {
		if userMap, ok := messageMap[v]; ok {
			for _, u := range userList {
				if _, ok := userMap[u.UserId]; !ok {
					sendMsg = append(sendMsg, &models.SysMessageReport{
						UserId:           u.UserId,
						ReceiveSysUserId: v,
						MessageType:      messagetType,
						IsRead:           false,
						CreateTime:       time.Now(),
						ModifyTime:       time.Now(),
						Content:          fmt.Sprintf(layout, u.RealName, messagetType),
					})
				}
			}
		} else {
			for _, u := range userList {
				sendMsg = append(sendMsg, &models.SysMessageReport{
					UserId:           u.UserId,
					ReceiveSysUserId: v,
					MessageType:      messagetType,
					IsRead:           false,
					CreateTime:       time.Now(),
					ModifyTime:       time.Now(),
					Content:          fmt.Sprintf(layout, u.RealName, messagetType),
				})
			}
		}
	}
	if len(sendMsg) > 0 {
		err = models.InsertMultiSysMessageReport(sendMsg)
	}
	return
}