younggee_m_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"
	"youngee_m_api/consts"
	"youngee_m_api/db"
	"youngee_m_api/model/gorm_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,
				Id:           talentList[i].Id,
				RefreshToken: re.RefreshToken,
				AccessToken:  re.AccessToken,
			}
			err1 := db.UpdateKuaishouUserInfoById(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
}