opms_backend/opms_parent/app/service/plat/plat_task_cron.go

package plat

import (
	model "dashoo.cn/micro/app/model/plat"
	"dashoo.cn/micro/app/service"
	"database/sql"
	"fmt"
	"github.com/gogf/gf/frame/g"
	"github.com/gogf/gf/os/glog"
	"github.com/gogf/gf/os/gtime"
	"github.com/gogf/gf/util/gconv"
	"github.com/robfig/cron"
	"strings"
	"time"
)

// 初始化，创建每10分钟执行一次的定时任务
func init() {
	// 定时任务
	c := cron.New()
	spec := "0 0 20 * * ?" // 每晚8点定时提醒

	if err := c.AddJob(spec, taskCron{}); err != nil {
		glog.Error(err)
	}
	c.Start()
}

// 督办任务定时任务定义
type taskCron struct {
}

// Run 督办定时任务逻辑
func (c taskCron) Run() {
	tenant := g.Config().GetString("micro_srv.tenant")
	if tenant == "" {
		glog.Error("督办定时任务租户码未设置，请前往配置")
		return
	}
	// 从配置中获取消息提醒设置
	configs, err := g.DB(tenant).Model("sys_config").Where("config_key IN ('TaskOverdueBefore','TaskOverdueAfter')").FindAll()
	if err != nil && err != sql.ErrNoRows {
		glog.Error(err)
		return
	}
	before := -1
	after := -1
	// 获取
	for _, config := range configs {
		if config["config_key"].String() == "TaskOverdueBefore" {
			before = gconv.Int(config["config_value"].String())
		} else if config["config_key"].String() == "TaskOverdueAfter" {
			after = gconv.Int(config["config_value"].String())
		}
	}
	// 校验
	if before == -1 || after == -1 {
		glog.Error("督办定时任务超期提醒参数未配置，请前往配置")
		return
	}
	// 查询数据，启用定时任务
	var tasks []*model.PlatTask
	var handles []*model.PlatTaskHandle
	needReceiveMap := make(map[int]int)
	err = g.DB(tenant).Model("plat_task").Where("task_status='10' OR task_status='20'").Scan(&tasks)
	if err != nil && err != sql.ErrNoRows {
		glog.Error(err)
		return
	}
	err = g.DB(tenant).Model("plat_task_handle").Where("task_status='10' AND step='10'").Scan(&handles)
	if err != nil && err != sql.ErrNoRows {
		glog.Error(err)
		return
	}
	for _, handle := range handles {
		needReceiveMap[handle.TaskId] = 1
	}

	receiveData := make(map[int]string)
	feedbackData := make(map[int]string)
	beforeOverdueData := make(map[int]string)
	afterOverdueData := make(map[int]string)

	// 当前时间
	now := gtime.Now()
	nowStr := gtime.Now().Format("Y-m-d")
	// 生成提醒数据
	for _, task := range tasks {
		// 任务接收提醒
		if task.ReceiveDate == nil {
			if _, ok := needReceiveMap[task.Id]; ok {
				generateData(&receiveData, task.MainUserId, task.OwnerUserId, task.TaskTitle)
			}
		}

		// 定期反馈提醒
		// 固定日期提醒
		if task.ReminderRule != "" {
			rules := strings.Split(task.ReminderRule, " ")
			if len(rules) != 5 {
				glog.Error(fmt.Sprintf("%v督办Id为%v提醒规则格式不正确", task.TaskTitle, task.Id))
			} else {
				if rules[3] == "*" { // 每天提醒
					generateData(&feedbackData, task.MainUserId, task.OwnerUserId, task.TaskTitle)
				} else if rules[3] == "?" { // 每周提醒
					// 校验周选项是否匹配
					weekDays := strings.Split(rules[4], ",")
					isMatch := false
					for _, day := range weekDays {
						if day == transferWeekday(now.Weekday()) {
							isMatch = true
							break
						}
					}
					if isMatch {
						generateData(&feedbackData, task.MainUserId, task.OwnerUserId, task.TaskTitle)
					}
				} else { // 每月提醒
					monthDays := strings.Split(rules[3], ",")
					isMatch := false
					for _, day := range monthDays {
						if gconv.Int(day) == now.Day() {
							isMatch = true
							break
						}
					}
					if isMatch {
						generateData(&feedbackData, task.MainUserId, task.OwnerUserId, task.TaskTitle)
					}
				}
			}
		}

		// 超期提醒
		if task.TaskEndDate != nil {
			// 超期前提醒
			beforeDate := task.TaskEndDate.AddDate(0, 0, before)
			if beforeDate.Format("Y-m-d") == nowStr {
				generateData(&beforeOverdueData, task.MainUserId, task.OwnerUserId, task.TaskTitle)
			}
			// 超期后提醒
			afterDate := task.TaskEndDate.AddDate(0, 0, -after)
			if afterDate.Format("Y-m-d") == nowStr {
				generateData(&afterOverdueData, task.MainUserId, task.OwnerUserId, task.TaskTitle)
			}
		}
	}
	for key, val := range receiveData {
		notifyMessage(gconv.String(key), val+"督办未接收，请前往处理")
	}
	for key, val := range feedbackData {
		notifyMessage(gconv.String(key), val+"督办需要处理，请前往处理")
	}
	for key, val := range beforeOverdueData {
		notifyMessage(gconv.String(key), val+"督办即将超期，请前往处理")
	}
	for key, val := range afterOverdueData {
		notifyMessage(gconv.String(key), val+"督办已超期，请确认")
	}
}

// 督办人任务的消息通知
func taskNotifyMessage(mainId int, ownerIds, message string) {
	// 协作人包含负责人的情况
	ids := ownerIds
	ownerIdArray := strings.Split(ownerIds, ",")
	isCon := false
	for _, id := range ownerIdArray {
		if id == gconv.String(mainId) {
			isCon = true
			break
		}
	}
	if !isCon {
		if ids == "" {
			ids = gconv.String(mainId)
		} else {
			ids += "," + gconv.String(mainId)
		}
	}
	// 调用统一的消息通知方式
	notifyMessage(ids, message)
}

func generateData(data *map[int]string, mainId int, ownerIds, info string) {
	isCon := false
	ownerIdArray := strings.Split(ownerIds, ",")
	for _, id := range ownerIdArray {
		if id == gconv.String(mainId) {
			isCon = true
			break
		}
	}
	if !isCon {
		if _, ok := (*data)[mainId]; !ok {
			(*data)[mainId] = info
		} else {
			(*data)[mainId] += "，" + info
		}
	}
	for _, id := range ownerIdArray {
		if id == "" {
			continue
		}
		if _, ok := (*data)[gconv.Int(id)]; !ok {
			(*data)[gconv.Int(id)] = info
		} else {
			(*data)[gconv.Int(id)] += "，" + info
		}
	}
}

// notifyMessage 发送消息通知
func notifyMessage(ids, message string) {
	msg := g.MapStrStr{
		"msgTitle":    "督办任务提醒",
		"msgContent":  fmt.Sprintf("%v", message),
		"msgType":     "20",
		"recvUserIds": ids,
		"msgStatus":   "10",
		"sendType":    "30",
	}
	if err := service.CreateSystemMessage(msg); err != nil {
		glog.Error("消息提醒异常：", err)
	}
}

// 英文周转换为中文周
func transferWeekday(day time.Weekday) string {
	switch day {
	case time.Monday:
		return "1"
	case time.Tuesday:
		return "2"
	case time.Wednesday:
		return "3"
	case time.Thursday:
		return "4"
	case time.Friday:
		return "5"
	case time.Saturday:
		return "6"
	case time.Sunday:
		return "7"
	default:
		return "-1"
	}
}