youngee_b_api/service/auto_task.go

package service

import (
	"context"
	"fmt"
	"github.com/caixw/lib.go/conv"
	"github.com/lin-jim-leon/kuaishou"
	"github.com/robfig/cron/v3"
	"github.com/sirupsen/logrus"
	"log"
	"strconv"
	"time"
	"youngee_m_api/consts"
	"youngee_m_api/db"
	"youngee_m_api/model/gorm_model"
	"youngee_m_api/model/http_model"
)

func AutoTask() error {
	// 新建一个定时任务对象
	// 根据cron表达式进行时间调度，cron可以精确到秒，大部分表达式格式也是从秒开始。
	// crontab := cron.New()  默认从分开始进行时间调度
	crontab := cron.New(cron.WithSeconds()) //精确到秒
	// 定义定时器调用的任务函数
	// 定时任务 自动查询更新项目快递的签收情况
	taskKDStatus := func() {
		// 在YoungeeTaskLogistics表中取出状态为未签收的快递
		logisticNums := db.GetLogisticsNum()
		for i := 0; i < len(logisticNums); i++ {
			logisticNum := logisticNums[i]
			// println("logisticNum[0]: ", logisticNum[0])
			// logisticNum[0]是快递公司名称 logisticNum[1]为快递编号
			status := GetKDStatus(consts.GetKD(logisticNum[0]), logisticNum[1])
			// status 返回的是快递100接口的状态码，1表示已签收
			if status == "1" {
				// logisticNum[2]为货物id
				// db.SignLogistic变更了项目任务的状态，并且返回了项目任务的id
				taskId := db.SignLogistic(conv.MustInt64(logisticNum[2], 0))
				// println("length of taskid: ", len(taskId))
				// 记录任务日志
				err := db.CreateTaskLog(context.Background(), taskId, "签收时间")
				if err != nil {
					logrus.WithContext(context.Background()).Errorf("[logistics service] call CreateTaskLog error,err:%+v", err)
					return
				}
			}
		}
	}

	//	定时任务1 ，线下探店打卡的自动签收操作
	task1 := func() {
		DB := db.GetReadDB(context.Background())
		autoTaskTime := gorm_model.InfoAutoTask{}
		DB.Model(gorm_model.InfoAutoTask{}).Last(&autoTaskTime)
		if autoTaskTime.SignInOffline != 0 {
			err := db.GetSignInOfflineTask(3)
			if err != nil {
				logrus.Error("[GetSignInOfflineTask] in DB error %+v", err)
				return
			}
		}
		log.Println("GetSignInOfflineTask is running ,Time :", time.Now())
	}

	// 定时任务2 ，虚拟产品测评的自动签收操作
	task2 := func() {
		DB := db.GetReadDB(context.Background())
		autoTaskTime := gorm_model.InfoAutoTask{}
		DB.Model(gorm_model.InfoAutoTask{}).Last(&autoTaskTime)
		if autoTaskTime.SignInVirtual != 0 {
			err := db.GetSignInOfflineTask(2)
			if err != nil {
				logrus.Error("[GetSignInVirtualTask] in DB error %+v", err)
				return
			}
		}
		log.Println("GetSignInVirtualTask is running ,Time :", time.Now())
	}

	// 定时任务3 ，视频形式的审稿处理
	task3 := func() {
		DB := db.GetReadDB(context.Background())
		autoTaskTime := gorm_model.InfoAutoTask{}
		DB.Model(gorm_model.InfoAutoTask{}).Last(&autoTaskTime)
		if autoTaskTime.ReviewInMv != 0 {
			err := db.GetAutoReviewTask(2)
			if err != nil {
				logrus.Error("[GetAutoReviewTask] in DB error %+v", err)
				return
			}
		}
		log.Println("GetAutoReviewTask is running ,Time :", time.Now())
	}

	// 定时任务4 ，不限形式的审稿处理
	task4 := func() {
		DB := db.GetReadDB(context.Background())
		autoTaskTime := gorm_model.InfoAutoTask{}
		DB.Model(gorm_model.InfoAutoTask{}).Last(&autoTaskTime)
		if autoTaskTime.ReviewUnlimited != 0 {
			err := db.GetAutoReviewTask(0)
			if err != nil {
				logrus.Error("[GetAutoReviewUnlimitedTask] in DB error %+v", err)
				return
			}
		}
		log.Println("GetAutoReviewUnlimitedTask is running ,Time :", time.Now())
	}

	// 定时任务5 ，发布审核自动处理
	task5 := func() {
		DB := db.GetReadDB(context.Background())
		autoTaskTime := gorm_model.InfoAutoTask{}
		DB.Model(gorm_model.InfoAutoTask{}).Last(&autoTaskTime)
		if autoTaskTime.Postreview != 0 {
			err := db.GetAutoPostReviewTask()
			if err != nil {
				logrus.Error("[GetAutoPostReviewTask] in DB error %+v", err)
				return
			}
		}
		log.Println("GetAutoPostReviewTask is running ,Time :", time.Now())
	}

	// 定时任务6 ，项目结案自动处理
	task6 := func() {
		DB := db.GetReadDB(context.Background())
		autoTaskTime := gorm_model.InfoAutoTask{}
		DB.Model(gorm_model.InfoAutoTask{}).Last(&autoTaskTime)
		if autoTaskTime.CaseClose != 0 {
			err := db.GetAutoCaseCloseTask()
			if err != nil {
				logrus.Error("[GetAutoCaseCloseTask] in DB error %+v", err)
				return
			}
		}
		log.Println("GetAutoCaseCloseTask is running ,Time :", time.Now())
	}

	// 定时任务7  全流程项目失效自动处理
	task7 := func() {
		DB := db.GetReadDB(context.Background())
		autoTaskTime := gorm_model.InfoAutoTask{}
		DB.Model(gorm_model.InfoAutoTask{}).Last(&autoTaskTime)
		if autoTaskTime.Invalid != 0 {
			err := db.GetAutoInvalidTask()
			if err != nil {
				logrus.Error("[GetAutoInvalidTask] in DB error %+v", err)
				return
			}
		}
		log.Println("GetAutoInvalidTask is running ,Time :", time.Now())
	}

	// 定时任务8.图文形式的初稿违约自动处理
	task8 := func() {
		DB := db.GetReadDB(context.Background())
		autoTaskTime := gorm_model.InfoAutoTask{}
		DB.Model(gorm_model.InfoAutoTask{}).Last(&autoTaskTime)
		if autoTaskTime.DraftDefaultInPic != 0 {
			err := db.GetAutoDraftDefaultInPicTask()
			if err != nil {
				logrus.Error("[GetAutoDraftDefaultInPicTask] in DB error %+v", err)
				return
			}
		}
		log.Println("GetAutoDraftDefaultInPicTask is running ,Time :", time.Now())
	}

	// 定时任务9.视频形式的初稿违约自动处理
	task9 := func() {
		DB := db.GetReadDB(context.Background())
		var DraftDefaultInMvTime int32
		DB.Select("draft_default_in_mv").Model(gorm_model.InfoAutoTask{}).Last(&DraftDefaultInMvTime)
		if DraftDefaultInMvTime != 0 {
			err := db.GetAutoDraftDefaultInMvTask()
			if err != nil {
				logrus.Error("[GetAutoDraftDefaultInMvTask] in DB error %+v", err)
				return
			}
		}
		log.Println("GetAutoDraftDefaultInMvTask is running ,Time :", time.Now())
	}

	// 定时任务10.视频形式的脚本违约自动处理
	task10 := func() {
		DB := db.GetReadDB(context.Background())
		var scriptDefault int32
		DB.Select("script_default").Model(gorm_model.InfoAutoTask{}).Last(&scriptDefault)
		if scriptDefault != 0 {
			err := db.GetAutoScriptDefaultTask()
			if err != nil {
				logrus.Error("[GetAutoScriptDefaultTask] in DB error %+v", err)
				return
			}
		}
		log.Println("GetAutoScriptDefaultTask is running ,Time :", time.Now())
	}

	// 定时任务11.链接违约自动处理
	task11 := func() {
		DB := db.GetReadDB(context.Background())
		var LinkBreach int32
		DB.Select("link_breach").Model(gorm_model.InfoAutoTask{}).Last(&LinkBreach)
		if LinkBreach != 0 {
			err := db.GetAutoLinkBreachTask()
			if err != nil {
				logrus.Error("[GetAutoLinkBreachTask] in DB error %+v", err)
				return
			}
		}
		log.Println("GetAutoLinkBreachTask is running ,Time :", time.Now())
	}

	// 定时任务12.数据违约自动处理
	task12 := func() {
		DB := db.GetReadDB(context.Background())
		var LinkBreach int32
		DB.Select("case_close_default").Model(gorm_model.InfoAutoTask{}).Last(&LinkBreach)
		if LinkBreach != 0 {
			err := db.GetAutoCaseCloseDefaultTask()
			if err != nil {
				logrus.Error("[GetAutoCaseCloseDefaultTask] in DB error %+v", err)
				return
			}
		}
		log.Println("GetAutoCaseCloseDefaultTask is running ,Time :", time.Now())
	}

	//定时任务13. 选品项目失效自动处理
	task13 := func() {
		// println("AWdawdawdawdawd")
		DB := db.GetReadDB(context.Background())
		autoTaskTime := gorm_model.InfoAutoTask{}
		DB.Model(gorm_model.InfoAutoTask{}).Last(&autoTaskTime)
		if autoTaskTime.SelectionInvalid != 0 {
			err := db.GetAutoSelectionInvalidTask()
			if err != nil {
				logrus.Error("[GetAutoInvalidTask] in DB error %+v", err)
				return
			}
		}
		log.Println("GetAutoSelectionInvalidTask is running ,Time :", time.Now())
	}

	//定时任务14. 拉取快手平台达人实际销量
	task14 := func() {
		ctx := context.Background()
		//筛选出所有执行中的Selection
		selectionIds, _ := db.FindSelectionIdBySelectionStatus(ctx, 6)
		for i := range len(selectionIds) {
			var SelectionId string = selectionIds[i]
			println("开始拉取快手平台达人实际销量")
			err1 := SelectionTask.UpdateActualNumBySelectionId(ctx, SelectionId)
			fmt.Println(err1)
			println("完成拉取快手平台达人实际销量")
		}
	}

	//定时任务15 定时刷新AccessToken
	task15 := func() {
		println("开始自动刷新AccessToken")
		//var refreshkey string = "ChJvYXV0aC5yZWZyZXNoVG9rZW4SsAGQCXElJ20T3HTrDjxxZV9rrR7R2YzBymWjhdwmxs7mtu4GWiT2cy6JIAq0CWpa7P235JMrzfkWGn0qkTENul1TDd2n-cKQsJkuzUTD19ju1X1MuTLGcAqAPLbdJNkta79MJAN6xbhLylkEgOp7xte4XxT1jhmUqKjB_nL5EkdujoJttqo4-uq_HrisXkoQVFX8BIHdyLrLayqcjTxHXSHQJTvQVCH1NE-kTyOqaPgtVBoS15q2jT8K34-pnrlOMxuV8Ep1IiDVSApx1ijnxstgKmdo6vTNOXLkVwwn1YMBy4Z0fZrnPSgFMAE"
		var AppKey string = "ks651333097154138217"
		var SignSecret string = "dBt0rVRhTpUqcrOYGGpv0A"
		//re, err := kuaishou.RefreshAccessToken(refreshkey, AppKey, SignSecret)
		//fmt.Println("AccessToken: ", re.AccessToken)
		//fmt.Println("ResreshToken: ", re.RefreshToken)
		//fmt.Println("err: ", err)
		ctx := context.Background()

		talentList := db.GetAllKuaishouUser(ctx)

		for i, _ := range talentList {
			var refreshkey string = talentList[i].RefreshToken
			re, err := kuaishou.RefreshAccessToken(refreshkey, AppKey, SignSecret)
			fmt.Println(err)
			newKuaishouUserInfo := gorm_model.PlatformKuaishouUserInfo{
				TalentId:     talentList[i].TalentId,
				RefreshToken: re.RefreshToken,
				AccessToken:  re.AccessToken,
			}
			err1 := db.UpdateKuaishouUserInfoByTalentID(ctx, newKuaishouUserInfo)
			fmt.Println(err1)
		}
		println("完成自动刷新AccessToken")
	}

	// 定时任务16 自动结算
	task16 := func() {
		ctx := context.Background()
		//筛选出所有执行中的Selection
		selectionIds, _ := db.FindSelectionIdBySelectionStatus(ctx, 6)
		for i := range len(selectionIds) {
			var SelectionId string = selectionIds[i]

			println("开始自动结算")
			var SecTaskStatus = 9
			var PageSize = int64(0)
			var PageNum = int64(0)
			var SearchValue = ""
			secTaskList, total, err2 := db.GetSecTaskList(ctx, SelectionId, SecTaskStatus, SearchValue, PageSize, PageNum)
			fmt.Println(err2)
			fmt.Println("待自动结算的子任务数量: ", total)
			selection_curr, _ := db.GetSelectionById(ctx, SelectionId)
			rewardStrategy, _ := db.GetRewardStrategyBySelectionId(ctx, SelectionId)
			for j, _ := range secTaskList {
				var secTaskId = secTaskList[j].SecTaskId
				settleData := http_model.SettleSecTaskRequest{
					SelectionID:   SelectionId,
					TaskID:        secTaskId,
					EnterpriseId:  selection_curr.EnterpriseID,
					TotalPayMoney: strconv.FormatFloat(rewardStrategy[0].PerReward, 'f', -1, 64),
					IsPayReward:   1,
				}
				_, err3 := SelectionTask.Settle(ctx, selection_curr.EnterpriseID, settleData)
				fmt.Println("结算报错: ", err3)
			}
			println("完成自动结算")
		}
	}

	//定时任务
	spec := "*/30 * * * * ?" //cron表达式，每30秒一次
	//spec := "0 */1 * * * ?" //cron表达式，每一分钟执行一次
	//spec := "0 0 * * * *" //每小时执行
	// "0 0 12 * * ?" 每天中午12点执行
	// 添加定时任务,
	_, err := crontab.AddFunc("0 0 * * * *", taskKDStatus) //每小时执行一次快递是否签收的查询
	//_, err := crontab.AddFunc("0 */1 * * * ?", taskKDStatus) //每分钟执行一次快递是否签收的查询
	if err != nil {
		return err
	}
	_, err1 := crontab.AddFunc(spec, task1)
	if err1 != nil {
		return err1
	}
	_, err2 := crontab.AddFunc(spec, task2)
	if err2 != nil {
		return err2
	}
	_, err3 := crontab.AddFunc(spec, task3)
	if err3 != nil {
		return err3
	}
	_, err4 := crontab.AddFunc(spec, task4)
	if err4 != nil {
		return err4
	}
	_, err5 := crontab.AddFunc(spec, task5)
	if err5 != nil {
		return err5
	}
	_, err6 := crontab.AddFunc(spec, task6)
	if err6 != nil {
		return err6
	}
	_, err7 := crontab.AddFunc(spec, task7)
	if err7 != nil {
		return err7
	}
	_, err8 := crontab.AddFunc(spec, task8)
	if err8 != nil {
		return err8
	}
	_, err9 := crontab.AddFunc(spec, task9)
	if err9 != nil {
		return err9
	}
	_, err10 := crontab.AddFunc(spec, task10)
	if err10 != nil {
		return err10
	}
	_, err11 := crontab.AddFunc(spec, task11)
	if err11 != nil {
		return err11
	}
	_, err12 := crontab.AddFunc(spec, task12)
	if err12 != nil {
		return err12
	}
	_, err13 := crontab.AddFunc(spec, task13)
	if err13 != nil {
		return err13
	}
	_, err14 := crontab.AddFunc(spec, task14)
	if err14 != nil {
		return err14
	}
	_, err15 := crontab.AddFunc(spec, task15)
	if err15 != nil {
		return err15
	}
	_, err16 := crontab.AddFunc(spec, task16)
	if err16 != nil {
		return err16
	}
	// 启动定时器
	crontab.Start()
	// 定时任务是另起协程执行的,这里使用 select 简单阻塞.需要根据实际情况进行控制
	//select {} //阻塞主线程停止
	return nil
}