younggee_m_api/db/operate.go

package db

import (
	"context"
	"fmt"
	"log"
	"reflect"
	"time"
	"youngee_m_api/model/common_model"
	"youngee_m_api/model/gorm_model"
	"youngee_m_api/model/http_model"
	"youngee_m_api/util"

	"github.com/caixw/lib.go/conv"
	"github.com/sirupsen/logrus"
	"gorm.io/gorm"
)

func CreatePricingStrategy(ctx context.Context, req *http_model.AddPricingRequest) (string, string, error) {
	db := GetReadDB(ctx)
	project_type, fee_form, platform, fans_low, fans_up, service_charge, service_rate := req.ProjectType, req.ManuscriptForm, req.Platform, req.FansLow, req.FansHigh, req.ServiceCharge, req.ServiceRate*10
	var IsExclusive, IsExclusive2, IsExclusive3, IsExclusive1 gorm_model.InfoPricingStrategy
	err := db.Where(" fee_form = ? && platform = ? && fans_low <= ? && fans_up >= ?", fee_form, platform, fans_low, fans_up).First(&IsExclusive).Error
	if err == nil {
		return "该策略与已经运行的策略互斥，请修改相关字段后重新创建", "", nil
	}
	err = db.Where(" fee_form = ? && platform = ? && fans_low < ? && fans_up > ?", fee_form, platform, fans_low, fans_low).First(&IsExclusive1).Error
	if err == nil {
		return "该策略与已经运行的策略互斥，请修改相关字段后重新创建", "", nil
	}
	err = db.Where(" fee_form = ? && platform = ? && fans_low < ? && fans_up > ?", fee_form, platform, fans_up, fans_up).First(&IsExclusive2).Error
	if err == nil {
		return "该策略与已经运行的策略互斥，请修改相关字段后重新创建", "", nil
	}
	err = db.Where(" fee_form = ? && platform = ? && fans_low >= ? && fans_up <= ?", fee_form, platform, fans_low, fans_up).First(&IsExclusive3).Error
	if err == nil {
		return "该策略与已经运行的策略互斥，请修改相关字段后重新创建", "", nil
	}
	var newStrategy gorm_model.InfoPricingStrategy
	var strategyInfo gorm_model.InfoPricingStrategy
	getMonth := time.Now().Format("01") //获取月
	getDay := time.Now().Day()          //获取日
	dayString := ""
	if getDay < 10 {
		dayString = conv.MustString(getDay, "")
		dayString = "0" + dayString
	} else {
		dayString = conv.MustString(getDay, "")
	}
	monthAndDay := conv.MustString(getMonth, "") + dayString
	err = db.Where(fmt.Sprintf(" strategyId like '%s%%'", monthAndDay)).Last(&strategyInfo).Error

	num := 1
	if strategyInfo.StrategyId != "" {
		num = conv.MustInt(strategyInfo.StrategyId[4:6], 0)
		num = num + 1 //获取日
	} else {
		num = 1
	}
	numString := ""
	if num < 10 {
		numString = conv.MustString(num, "")
		numString = "0" + numString
	} else {
		numString = conv.MustString(num, "")
	}
	newStrategy.StrategyId = monthAndDay + numString
	newStrategy.Status = 0
	newStrategy.FansLow = fans_low
	newStrategy.FansUp = fans_up
	newStrategy.ProjectType = conv.MustInt64(project_type, 0)
	newStrategy.ServiceCharge = conv.MustFloat32(service_charge, 0)
	newStrategy.Platform = conv.MustInt64(platform, 0)
	newStrategy.FeeForm = conv.MustInt64(fee_form, 0)
	newStrategy.ServiceRate = conv.MustInt64(service_rate, 0)
	newStrategy.CreateAt = time.Now()
	newStrategy.UpdateAt = time.Now()
	err = db.Create(&newStrategy).Error
	if err != nil {
		return "创建失败", "", err
	}
	return "创建成功", monthAndDay + numString, nil
}

func SearchPricing(ctx context.Context, pageSize, pageNum int32, conditions *common_model.PricingConditions) ([]*gorm_model.InfoPricingStrategy, int64, error) {
	db := GetReadDB(ctx)
	db = db.Model(gorm_model.InfoPricingStrategy{})
	// 根据 查询条件过滤
	conditionType := reflect.TypeOf(conditions).Elem()
	conditionValue := reflect.ValueOf(conditions).Elem()
	for i := 0; i < conditionType.NumField(); i++ {
		field := conditionType.Field(i)
		tag := field.Tag.Get("condition")
		value := conditionValue.FieldByName(field.Name)
		if !util.IsBlank(value) && tag != "update_at" {
			db = db.Where(fmt.Sprintf("%s = ?", tag), value.Interface())
		} else if tag == "update_at" && value.Interface() != nil {
			db = db.Where(fmt.Sprintf("update_at like '%s%%'", value.Interface()))
		}
	}
	// 查询总数
	var total int64
	var PricingDatas []*gorm_model.InfoPricingStrategy
	if err := db.Count(&total).Error; err != nil {
		logrus.WithContext(ctx).Errorf("[SearchPricing] error query mysql total, err:%+v", err)
		return nil, 0, err
	}
	// 查询该页数据
	limit := pageSize
	offset := pageSize * pageNum // assert pageNum start with 0
	err := db.Order("update_at desc").Limit(int(limit)).Offset(int(offset)).Find(&PricingDatas).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[SearchPricing] error query mysql find, err:%+v", err)
		return nil, 0, err
	}
	return PricingDatas, total, nil
}

func ModifyPricing(ctx context.Context, req *http_model.ModifyPricingRequest) (int, error) {
	db := GetReadDB(ctx)
	strategyId := req.StrategyId
	db = db.Model(gorm_model.InfoPricingStrategy{}).Where("strategyId = ?", strategyId)
	project_type, fee_form, platform, fans_low, fans_up, service_charge, service_rate := req.ProjectType, req.FeeForm, req.Platform, req.FansLow, req.FansHigh, req.ServiceCharge, req.ServiceRate*10
	var IsExclusive, IsExclusive2, IsExclusive3, IsExclusive1 int64
	err := db.Where("strategyId <> ? && fee_form = ? && platform = ? && fans_low <= ? && fans_up >= ?", strategyId, fee_form, platform, fans_low, fans_up).Count(&IsExclusive).Error
	if IsExclusive != 0 {
		return 1, nil
	}
	err = db.Where("strategyId <> ? && fee_form = ? && platform = ? && fans_low < ? && fans_up > ?", strategyId, fee_form, platform, fans_low, fans_low).Count(&IsExclusive1).Error
	if IsExclusive1 != 0 {
		return 1, nil
	}
	err = db.Where("strategyId <> ? && fee_form = ? && platform = ? && fans_low < ? && fans_up > ?", strategyId, fee_form, platform, fans_up, fans_up).Count(&IsExclusive2).Error
	if IsExclusive2 != 0 {
		return 1, nil
	}
	err = db.Where("strategyId <> ? && fee_form = ? && platform = ? && fans_low >= ? && fans_up <= ?", strategyId, fee_form, platform, fans_low, fans_up).Count(&IsExclusive3).Error
	if IsExclusive3 != 0 {
		return 1, nil
	}
	if err != nil {
		fmt.Printf("[ModifyPricing] error query mysql find, err:%+v", err)
		logrus.WithContext(ctx).Errorf("[ModifyPricing] error query mysql find, err:%+v", err)
		return 2, err
	}
	fmt.Printf("service_rate:%+v", service_rate)
	db1 := GetReadDB(ctx).Model(gorm_model.InfoPricingStrategy{}).Where("strategyId = ?", strategyId)
	err1 := db1.Updates(map[string]interface{}{
		"project_type": project_type, "service_rate": service_rate, "fee_form": fee_form,
		"platform": platform, "fans_low": fans_low, "fans_up": fans_up, "service_charge": service_charge,
	}).Error
	if err1 != nil {
		fmt.Printf("[ModifyPricing] error query mysql update, err:%+v", err)
		logrus.WithContext(ctx).Errorf("[ModifyPricing] error query mysql update, err:%+v", err)
		return 2, err
	}
	return 0, nil
}

func UpdateAutoTaskTime(ctx context.Context, time int32, num int32) error {
	db := GetReadDB(ctx)
	var autoTaskInfo gorm_model.InfoAutoTask
	err := db.Model(gorm_model.InfoAutoTask{}).Last(&autoTaskInfo).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[UpdateAutoTaskTime] error get Last mysql, err:%+v", err)
		return err
	}
	switch num {
	case 1:
		autoTaskInfo.SignInOffline = time
	case 2:
		autoTaskInfo.SignInVirtual = time
	case 3:
		autoTaskInfo.ReviewInMv = time
	case 4:
		autoTaskInfo.ReviewUnlimited = time
	case 5:
		autoTaskInfo.Postreview = time
	case 6:
		autoTaskInfo.CaseClose = time
	case 7:
		autoTaskInfo.Invalid = time
	case 8:
		autoTaskInfo.DraftDefaultInPic = time
	case 9:
		autoTaskInfo.DraftDefaultInMv = time
	case 10:
		autoTaskInfo.ScriptDefault = time
	case 11:
		autoTaskInfo.LinkBreach = time
	case 12:
		autoTaskInfo.CaseCloseDefault = time
	}
	autoTaskInfo.AutoTaskID += 1
	err = db.Model(gorm_model.InfoAutoTask{}).Create(&autoTaskInfo).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[UpdateAutoTaskTime] error Create mysql, err:%+v", err)
		return err
	}
	return nil
}

func UpdateAutoDefaultRate(ctx context.Context, rate int, num int32) error {
	db := GetReadDB(ctx)
	autoDefaultRateInfo := gorm_model.InfoAutoDefaultHandle{}
	err := db.Model(&gorm_model.InfoAutoDefaultHandle{}).Last(&autoDefaultRateInfo).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[UpdateAutoDefaultRate] error get Last mysql, err:%+v", err)
		return err
	}
	switch num {
	case 1:
		autoDefaultRateInfo.SketchReplaceNotUpload = rate
	case 2:
		autoDefaultRateInfo.SketchReplaceTimeOut = rate
	case 3:
		autoDefaultRateInfo.SketchOtherNotUpload = rate
	case 4:
		autoDefaultRateInfo.SketchOtherTimeOut = rate
	case 5:
		autoDefaultRateInfo.ScriptReplaceNotUpload = rate
	case 6:
		autoDefaultRateInfo.ScriptReplaceTimeOut = rate
	case 7:
		autoDefaultRateInfo.ScriptOtherNotUpload = rate
	case 8:
		autoDefaultRateInfo.ScriptOtherTimeOut = rate
	case 9:
		autoDefaultRateInfo.LinkReplaceNotUpload = rate
	case 10:
		autoDefaultRateInfo.LinkReplaceTimeOut = rate
	case 11:
		autoDefaultRateInfo.LinkOtherNotUpload = rate
	case 12:
		autoDefaultRateInfo.LinkOtherTimeOut = rate
	case 13:
		autoDefaultRateInfo.DataReplaceNotUpload = rate
	case 14:
		autoDefaultRateInfo.DataReplaceTimeOut = rate
	case 15:
		autoDefaultRateInfo.DataOtherNotUpload = rate
	case 16:
		autoDefaultRateInfo.DataOtherTimeOut = rate
	}
	autoDefaultRateInfo.AutoDefaultID += 1
	err = db.Model(&gorm_model.InfoAutoDefaultHandle{}).Create(autoDefaultRateInfo).Error
	if err != nil {
		logrus.WithContext(ctx).Errorf("[UpdateAutoDefaultRate] error Create mysql, err:%+v", err)
		return err
	}
	return nil
}

func GetSignInOfflineTask(projectForm int32) error {
	db := GetReadDB(context.Background())
	var projectInfos []*gorm_model.ProjectInfo
	err := db.Model(gorm_model.ProjectInfo{}).Where("project_type = ? AND project_form = ?", 1, projectForm).Find(&projectInfos).Error
	if err != nil {
		return err
	}
	projectIdMap := make(map[int64]int64)
	taskIDs := make(map[int]int)
	var projectIds []int64
	var taskIds []int
	var t int32
	for _, projectInfo := range projectInfos {
		autoTaskId := projectInfo.AutoTaskID
		dbStart := GetReadDB(context.Background())
		var autoTaskInfo gorm_model.InfoAutoTask
		dbStart.Model(gorm_model.InfoAutoTask{}).Where("auto_task_id = ?", autoTaskId).First(&autoTaskInfo)
		//fmt.Println("t:", autoTaskInfo.SignInOffline)
		if projectForm == 3 {
			t = autoTaskInfo.SignInOffline
		} else {
			t = autoTaskInfo.SignInVirtual
		}
		projectIds = append(projectIds, projectInfo.ProjectID)
		if _, ok := projectIdMap[projectInfo.ProjectID]; !ok {
			projectIdMap[projectInfo.ProjectID] = projectInfo.ContentType
			db1 := GetReadDB(context.Background())
			var taskInfos []gorm_model.YoungeeTaskInfo
			db1.Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND logistics_status = ?", projectInfo.ProjectID, 2).Find(&taskInfos)
			//fmt.Println("taskInfos", taskInfos)
			for _, taskInfo := range taskInfos {
				//fmt.Println("TaskId", taskInfo.TaskId)
				if _, ok1 := taskIDs[taskInfo.TaskId]; !ok1 {
					taskIds = append(taskIds, taskInfo.TaskId)
					taskIDs[taskInfo.TaskId] = taskInfo.ProjectId
					var logisticInfo gorm_model.YoungeeTaskLogistics
					db2 := GetReadDB(context.Background())
					db2.Model(gorm_model.YoungeeTaskLogistics{}).Where("task_id = ?", taskInfo.TaskId).Find(&logisticInfo)
					fmt.Println("logisticID", logisticInfo.LogisticsID)
					dd, _ := time.ParseDuration(conv.MustString(t, "") + "h")
					if logisticInfo.AutoSignAt.IsZero() {
						db5 := GetReadDB(context.Background())
						db5.Model(gorm_model.YoungeeTaskLogistics{}).Where("logistics_id = ?", logisticInfo.LogisticsID).
							Updates(&gorm_model.YoungeeTaskLogistics{AutoSignAt: logisticInfo.DeliveryTime.Add(dd)})
						fmt.Println("已添加自动签收时间")
					}
				}
			}
		}
	}
	//fmt.Println("projectIdMap", projectIdMap)
	//fmt.Println("taskIds", taskIds)
	var logisticInfos []gorm_model.YoungeeTaskLogistics
	db3 := GetReadDB(context.Background())
	err = db3.Model(gorm_model.YoungeeTaskLogistics{}).Where("auto_sign_at <= ? AND task_id IN ?", time.Now(), taskIds).Find(&logisticInfos).Error
	if err != nil {
		log.Println("DB AutoGetSignInOfflineTask error :", err)
		return err
	}
	var signedTaskId []int64
	for _, logisticInfo := range logisticInfos {
		signedTaskId = append(signedTaskId, logisticInfo.TaskID)
		if logisticInfo.SignedTime.IsZero() {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.YoungeeTaskLogistics{}).Where("logistics_id = ?", logisticInfo.LogisticsID).Updates(&gorm_model.YoungeeTaskLogistics{SignedTime: time.Now(), Status: 1})
			fmt.Println("已更新签收时间")
		}
	}
	util.RemoveRepByMap(signedTaskId)
	//fmt.Println("signedTaskId", signedTaskId)
	for _, taskID := range signedTaskId {
		//fmt.Println("taskID", taskID)
		db4 := GetReadDB(context.Background())
		taskNeedMod := gorm_model.YoungeeTaskInfo{}
		db4.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskID).Find(&taskNeedMod)
		if projectIdMap[int64(taskIDs[int(taskID)])] == 1 {
			if taskNeedMod.LogisticsStatus == 2 && taskNeedMod.TaskStage == 5 {
				db4.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskID).Updates(&gorm_model.YoungeeTaskInfo{LogisticsStatus: 3, TaskStage: 9})
				fmt.Println("内容形式为图片的项目 已修改任务状态为待传初稿 及物流状态为已签收")
			}
		} else if projectIdMap[int64(taskIDs[int(taskID)])] == 2 {
			if taskNeedMod.LogisticsStatus == 2 && taskNeedMod.TaskStage == 5 {
				db4.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskID).Updates(&gorm_model.YoungeeTaskInfo{LogisticsStatus: 3, TaskStage: 7})
				fmt.Println("内容形式为视频的项目 已修改任务状态为待传脚本 及物流状态为已签收")
			}
		}
	}
	return nil
}

func GetAutoReviewTask(contentType int32) error {
	db := GetReadDB(context.Background())
	var projectInfos []*gorm_model.ProjectInfo
	if contentType == 2 {
		err := db.Model(gorm_model.ProjectInfo{}).Where("project_type = ? AND content_type = ?", 1, contentType).Find(&projectInfos).Error
		if err != nil {
			return err
		}
		var projectIds []int64
		projectIdToAutoTaskIdMap := map[int64]int{}
		for _, projectInfo := range projectInfos {
			projectIds = append(projectIds, projectInfo.ProjectID)
			projectIdToAutoTaskIdMap[projectInfo.ProjectID] = int(projectInfo.AutoTaskID)
		}
		//fmt.Println("projectIds:", projectIds)
		TaskIdToProjectId := make(map[int]int)
		var taskId []int
		db1 := GetReadDB(context.Background())
		for _, projectId := range projectIds {
			// 获取 autoTaskId 及其对应的限制时间、
			autoTaskId := projectIdToAutoTaskIdMap[projectId]
			dbStart := GetReadDB(context.Background())
			var ReviewInMv int32
			dbStart.Model(gorm_model.InfoAutoTask{}).Select("review_in_mv").Where("auto_task_id = ?", autoTaskId).First(&ReviewInMv)
			//fmt.Println("t:", autoTaskInfo.ReviewInMv)
			// 获取 projectId 对应的 taskId 及添加脚本自动审核时间
			var taskInfos []gorm_model.YoungeeTaskInfo
			db1.Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ?", projectId).Find(&taskInfos)
			for _, taskInfo := range taskInfos {
				//fmt.Println("TaskID:", taskInfo.TaskId)
				taskId = append(taskId, taskInfo.TaskId)
				TaskIdToProjectId[taskInfo.TaskId] = int(projectId)
				db2 := GetReadDB(context.Background())
				var scriptInfos gorm_model.YounggeeScriptInfo
				db2.Model(gorm_model.YounggeeScriptInfo{}).Where("task_id = ? AND is_submit = ? AND is_review = ? ", taskInfo.TaskId, 1, 0).Find(&scriptInfos)
				dd, _ := time.ParseDuration(conv.MustString(ReviewInMv, "") + "h")
				if scriptInfos.AutoAgreeAt.IsZero() && scriptInfos.IsSubmit == 1 {
					db3 := GetReadDB(context.Background())
					db3.Model(gorm_model.YounggeeScriptInfo{}).Where("task_id = ?", taskInfo.TaskId).Updates(&gorm_model.YounggeeScriptInfo{AutoAgreeAt: scriptInfos.SubmitAt.Add(dd)})
					fmt.Println("已添加脚本自动审核时间")
				}
			}
		}
		//fmt.Println("TaskIdToProjectId:", TaskIdToProjectId)
		//fmt.Println("taskId:", taskId)

		var scriptInfos []gorm_model.YounggeeScriptInfo
		db4 := GetReadDB(context.Background())
		err = db4.Model(gorm_model.YounggeeScriptInfo{}).Where("auto_agree_at <= ? AND task_id IN ?", time.Now(), taskId).Find(&scriptInfos).Error
		if err != nil {
			log.Println("DB GetAutoReviewTask error in script :", err)
			return err
		}
		for _, scriptInfo := range scriptInfos {
			if scriptInfo.IsReview == 0 && scriptInfo.IsSubmit == 1 {
				db7 := GetReadDB(context.Background())
				db7.Model(gorm_model.YounggeeScriptInfo{}).Where("script_id = ?", scriptInfo.ScriptID).Updates(&gorm_model.YounggeeScriptInfo{AgreeAt: time.Now(), IsReview: 1, IsOk: 1})
				fmt.Println("已更新脚本同意时间 及脚本审核状态")

				taskStatusNeedMod := gorm_model.YoungeeTaskInfo{}
				db6 := GetReadDB(context.Background())
				db6.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", scriptInfo.TaskID).Find(&taskStatusNeedMod)
				if (taskStatusNeedMod.ScriptStatus == 2 || taskStatusNeedMod.ScriptStatus == 4) && taskStatusNeedMod.TaskStage == 8 {
					db8 := GetReadDB(context.Background())
					db8.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", scriptInfo.TaskID).Updates(&gorm_model.YoungeeTaskInfo{ScriptStatus: 5, TaskStage: 9})
					fmt.Println("已更新任务阶段为待传初稿 及脚本上传状态为已通过")
				}
			}
		}
		return nil
	} else {
		err := db.Model(gorm_model.ProjectInfo{}).Where("project_type = ? ", 1).Find(&projectInfos).Error
		if err != nil {
			return err
		}
		var projectIds []int64
		projectIdToAutoTaskIdMap := map[int64]int{}
		for _, projectInfo := range projectInfos {
			projectIds = append(projectIds, projectInfo.ProjectID)
			projectIdToAutoTaskIdMap[projectInfo.ProjectID] = int(projectInfo.AutoTaskID)
		}
		//fmt.Println("projectIds:", projectIds)
		TaskIdToProjectId := make(map[int]int)
		var taskId []int
		db1 := GetReadDB(context.Background())
		for _, projectId := range projectIds {
			// 获取 autoTaskId 及其对应的限制时间、
			autoTaskId := projectIdToAutoTaskIdMap[projectId]
			dbStart := GetReadDB(context.Background())
			var ReviewUnlimited int32
			dbStart.Model(gorm_model.InfoAutoTask{}).Select("review_unlimited").Where("auto_task_id = ?", autoTaskId).First(&ReviewUnlimited)
			//fmt.Println("t:", autoTaskInfo.ReviewUnlimited)
			var taskInfos []gorm_model.YoungeeTaskInfo
			db1.Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ?", projectId).Find(&taskInfos)
			for _, taskInfo := range taskInfos {
				TaskIdToProjectId[taskInfo.TaskId] = int(projectId)
				taskId = append(taskId, taskInfo.TaskId)
				db2 := GetReadDB(context.Background())
				var scriptInfos gorm_model.YounggeeSketchInfo
				db2.Model(gorm_model.YounggeeSketchInfo{}).Where("task_id = ? AND is_submit = ? AND is_review = ? ", taskInfo.TaskId, 1, 0).Find(&scriptInfos)
				dd, _ := time.ParseDuration(conv.MustString(ReviewUnlimited, "") + "h")
				if scriptInfos.AutoAgreeAt.IsZero() && scriptInfos.IsSubmit == 1 {
					db3 := GetReadDB(context.Background())
					db3.Model(gorm_model.YounggeeSketchInfo{}).Where("task_id = ?", scriptInfos.TaskID).Updates(&gorm_model.YounggeeSketchInfo{AutoAgreeAt: scriptInfos.SubmitAt.Add(dd)})
					fmt.Println("已添加初稿自动审核时间")
				}
			}
		}

		//fmt.Println("TaskIdToProjectId:", TaskIdToProjectId)
		//fmt.Println("taskId:", taskId)

		var sketchInfos []gorm_model.YounggeeSketchInfo
		db3 := GetReadDB(context.Background())
		err = db3.Model(gorm_model.YounggeeSketchInfo{}).Where("auto_agree_at <= ? AND task_id IN ?", time.Now(), taskId).Find(&sketchInfos).Error
		if err != nil {
			log.Println("DB GetAutoReviewTask error in sketch:", err)
			return err
		}
		for _, sketchInfo := range sketchInfos {
			if sketchInfo.IsReview != 1 && sketchInfo.IsSubmit == 1 {
				db6 := GetReadDB(context.Background())
				db6.Model(gorm_model.YounggeeSketchInfo{}).Where("sketch_id = ?", sketchInfo.SketchID).Updates(&gorm_model.YounggeeSketchInfo{AgreeAt: time.Now(), IsReview: 1, IsOk: 1})
				fmt.Println("已更新初稿审核同意时间")
				sketchNeedMod := gorm_model.YoungeeTaskInfo{}
				db5 := GetReadDB(context.Background())
				db5.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", sketchInfo.TaskID).Find(&sketchNeedMod)
				if (sketchNeedMod.SketchStatus == 2 || sketchNeedMod.SketchStatus == 4) && sketchNeedMod.TaskStage == 10 {
					db7 := GetReadDB(context.Background())
					db7.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", sketchInfo.TaskID).Updates(&gorm_model.YoungeeTaskInfo{SketchStatus: 5, TaskStage: 11})
					fmt.Println("已更新任务阶段为待传链接 及初稿上传状态为已通过")
				}
			}
		}
		return nil
	}
}

func GetAutoPostReviewTask() error {
	db := GetReadDB(context.Background())
	var projectInfos []*gorm_model.ProjectInfo
	err := db.Model(gorm_model.ProjectInfo{}).Where("project_type = ? ", 1).Find(&projectInfos).Error
	if err != nil {
		return err
	}
	var projectIds []int64
	projectIdToAutoTaskIdMap := map[int64]int{}
	for _, projectInfo := range projectInfos {
		projectIds = append(projectIds, projectInfo.ProjectID)
		projectIdToAutoTaskIdMap[projectInfo.ProjectID] = int(projectInfo.AutoTaskID)
	}
	//fmt.Println("projectIds:", projectIds)
	TaskIdToProjectId := make(map[int]int)
	var taskId []int
	db1 := GetReadDB(context.Background())
	for _, projectId := range projectIds {
		// 获取 autoTaskId 及其对应的限制时间、
		autoTaskId := projectIdToAutoTaskIdMap[projectId]
		dbStart := GetReadDB(context.Background())
		var Postreview int32
		dbStart.Model(gorm_model.InfoAutoTask{}).Select("postreview").Where("auto_task_id = ?", autoTaskId).First(&Postreview)
		//fmt.Println("t:", autoTaskInfo.Postreview)
		var taskInfos []gorm_model.YoungeeTaskInfo
		db1.Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ?", projectId).Find(&taskInfos)
		for _, taskInfo := range taskInfos {
			TaskIdToProjectId[taskInfo.TaskId] = int(projectId)
			taskId = append(taskId, taskInfo.TaskId)
			db2 := GetReadDB(context.Background())
			var linkInfos gorm_model.YounggeeLinkInfo
			db2.Model(gorm_model.YounggeeLinkInfo{}).Where("task_id = ? AND is_submit = ? AND is_review = ? ", taskInfo.TaskId, 1, 0).Find(&linkInfos)
			dd, _ := time.ParseDuration(conv.MustString(Postreview, "") + "h")
			if linkInfos.AutoAgreeAt.IsZero() && linkInfos.IsSubmit == 1 {
				db3 := GetReadDB(context.Background())
				db3.Model(gorm_model.YounggeeLinkInfo{}).Where("task_id = ?", linkInfos.TaskID).Updates(&gorm_model.YounggeeLinkInfo{AutoAgreeAt: linkInfos.SubmitAt.Add(dd)})
				fmt.Println("已添加链接自动审核时间")
			}
		}
	}
	var linkInfos []gorm_model.YounggeeLinkInfo
	db3 := GetReadDB(context.Background())
	err = db3.Model(gorm_model.YounggeeLinkInfo{}).Where("auto_agree_at <= ? AND task_id IN ?", time.Now(), taskId).Find(&linkInfos).Error
	if err != nil {
		log.Println("DB GetAutoPostReviewTask error in sketch:", err)
		return err
	}
	for _, linkInfo := range linkInfos {
		if linkInfo.IsReview != 1 && linkInfo.IsSubmit == 1 {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.YounggeeLinkInfo{}).Where("link_id = ?", linkInfo.LinkID).Updates(&gorm_model.YounggeeLinkInfo{AgreeAt: time.Now(), IsReview: 1, IsOk: 1})
			fmt.Println("已更新链接审核同意时间")
			linkNeedMod := gorm_model.YoungeeTaskInfo{}
			db5 := GetReadDB(context.Background())
			db5.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", linkInfo.TaskID).Find(&linkNeedMod)
			if (linkNeedMod.LinkStatus == 2 || linkNeedMod.LinkStatus == 4) && linkNeedMod.TaskStage == 12 {
				db7 := GetReadDB(context.Background())
				db7.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", linkInfo.TaskID).Updates(&gorm_model.YoungeeTaskInfo{LinkStatus: 5, TaskStage: 13})
				fmt.Println("已更新任务阶段为待传数据 及 链接上传状态为已通过")
			}
		}
	}
	return nil
}

func GetAutoCaseCloseTask() error {
	db := GetReadDB(context.Background())
	var projectInfos []*gorm_model.ProjectInfo
	err := db.Model(gorm_model.ProjectInfo{}).Where("project_type = ? ", 1).Find(&projectInfos).Error
	if err != nil {
		return err
	}
	var projectIds []int64
	projectIdToAutoTaskIdMap := map[int64]int{}
	for _, projectInfo := range projectInfos {
		projectIds = append(projectIds, projectInfo.ProjectID)
		projectIdToAutoTaskIdMap[projectInfo.ProjectID] = int(projectInfo.AutoTaskID)
	}
	//fmt.Println("projectIds:", projectIds)
	TaskIdToProjectId := make(map[int]int)
	var taskId []int
	db1 := GetReadDB(context.Background())
	for _, projectId := range projectIds {
		// 获取 autoTaskId 及其对应的限制时间
		autoTaskId := projectIdToAutoTaskIdMap[projectId]
		dbStart := GetReadDB(context.Background())
		var CaseClose int32
		dbStart.Model(gorm_model.InfoAutoTask{}).Select("case_close").Where("auto_task_id = ?", autoTaskId).First(&CaseClose)
		//fmt.Println("t:", autoTaskInfo.CaseClose)
		var taskInfos []gorm_model.YoungeeTaskInfo
		db1.Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ?", projectId).Find(&taskInfos)
		for _, taskInfo := range taskInfos {
			TaskIdToProjectId[taskInfo.TaskId] = int(projectId)
			taskId = append(taskId, taskInfo.TaskId)
			db2 := GetReadDB(context.Background())
			var dataInfos gorm_model.YounggeeDataInfo
			db2.Model(gorm_model.YounggeeDataInfo{}).Where("task_id = ? AND is_submit = ? AND is_review = ? ", taskInfo.TaskId, 1, 0).Find(&dataInfos)
			dd, _ := time.ParseDuration(conv.MustString(CaseClose, "") + "h")
			if dataInfos.AutoAgreeAt.IsZero() && dataInfos.IsSubmit == 1 {
				db3 := GetReadDB(context.Background())
				db3.Model(gorm_model.YounggeeDataInfo{}).Where("task_id = ?", dataInfos.TaskID).Updates(&gorm_model.YounggeeDataInfo{AutoAgreeAt: dataInfos.SubmitAt.Add(dd)})
				fmt.Println("已添加链接自动审核时间")
			}
		}
	}
	var dataInfos []gorm_model.YounggeeDataInfo
	db3 := GetReadDB(context.Background())
	err = db3.Model(gorm_model.YounggeeDataInfo{}).Where("auto_agree_at <= ? AND task_id IN ?", time.Now(), taskId).Find(&dataInfos).Error
	if err != nil {
		log.Println("DB GetAutoCaseCloseTask error in sketch:", err)
		return err
	}
	for _, dataInfo := range dataInfos {
		if dataInfo.IsReview != 1 && dataInfo.IsSubmit == 1 {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.YounggeeDataInfo{}).Where("data_id = ?", dataInfo.DataID).Updates(&gorm_model.YounggeeDataInfo{AgreeAt: time.Now(), IsReview: 1, IsOk: 1})
			fmt.Println("已更新数据审核同意时间")

			dataNeedMod := gorm_model.YoungeeTaskInfo{}
			db5 := GetReadDB(context.Background())
			db5.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", dataInfo.TaskID).Find(&dataNeedMod)
			if (dataNeedMod.DataStatus == 2 || dataNeedMod.DataStatus == 4) && dataNeedMod.TaskStage == 14 {
				db7 := GetReadDB(context.Background())
				db7.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", dataInfo.TaskID).Updates(&gorm_model.YoungeeTaskInfo{DataStatus: 5, TaskStage: 15})
				fmt.Println("已更新任务阶段为已结案 及 数据上传状态为已通过")
			}
		}
	}

	// 4. 判断是否全部任务已结案，若已全部结案则触发项目结案
	// 查询 task_stage<15 的任务数量
	for _, projectInfo := range projectInfos {
		var unFinishedTaskNumber int64
		db8 := GetReadDB(context.Background())
		err = db8.Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and task_status = 2 and task_stage < 15", projectInfo.ProjectID).Count(&unFinishedTaskNumber).Error
		if err != nil {
			log.Println("DB GetAutoCaseCloseTask error in data:", err)
			return err
		}
		// var finishedNum int64
		// db8.Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and task_status = 2 and task_stage >= 15", projectInfo.ProjectID).Count(&finishedNum)
		if unFinishedTaskNumber == 0 {
			// 若为0则触发项目结案
			db9 := GetReadDB(context.Background())
			// 1. 更新项目状态为已结束
			err := db9.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectInfo.ProjectID).Updates(map[string]interface{}{"project_status": 10}).Error
			if err != nil {
				log.Println("DB GetAutoCaseCloseTask error in data:", err)
				return err
			}
			// 2. 释放企业账户因项目冻结的资金
			// 	1）. 计算剩余资金
			var allPayment float64
			var realPayment float64
			err = db9.Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and task_status = 2 and task_stage >= 15", projectInfo.ProjectID).
				Pluck("COALESCE(SUM(all_payment), 0) as allPayment", &allPayment).Error
			if err != nil {
				log.Println("DB GetAutoCaseCloseTask error in data:", err)
				return err
			}
			err = db9.Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? and task_status = 2 and task_stage >= 15", projectInfo.ProjectID).
				Pluck("COALESCE(SUM(real_payment), 0) as realPayment", &realPayment).Error
			if err != nil {
				log.Println("DB GetAutoCaseCloseTask error in data:", err)
				return err
			}
			fmt.Println("企业应支付金额总计：", allPayment, "实际支付总计：", realPayment)

			// 	2）. 释放剩余资金
			err = db9.Model(gorm_model.Enterprise{}).Where("enterprise_id = ?", projectInfo.EnterpriseID).Updates(
				map[string]interface{}{
					"frozen_balance":    gorm.Expr("frozen_balance - ?", allPayment),
					"balance":           gorm.Expr("balance - ?", realPayment),
					"available_balance": gorm.Expr("available_balance + ?", allPayment-realPayment)}).Error
			if err != nil {
				log.Println("DB GetAutoCaseCloseTask error in data:", err)
				return err
			}
		}
	}
	return nil
}

func GetAutoInvalidTask() error {
	db := GetReadDB(context.Background())
	var projectInfos []*gorm_model.ProjectInfo
	err := db.Model(gorm_model.ProjectInfo{}).Where("project_type = ? AND project_status = ? ", 1, 6).Find(&projectInfos).Error
	if err != nil {
		return err
	}
	var projectIds []int64
	projectIdToAutoTaskIdMap := map[int64]int{}
	for _, projectInfo := range projectInfos {
		projectIds = append(projectIds, projectInfo.ProjectID)
		projectIdToAutoTaskIdMap[projectInfo.ProjectID] = int(projectInfo.AutoTaskID)
	}
	for _, projectId := range projectIds {
		// 获取 autoTaskId 及其对应的限制时间、
		autoTaskId := projectIdToAutoTaskIdMap[projectId]
		dbStart := GetReadDB(context.Background())
		var Invalid int32
		dbStart.Model(gorm_model.InfoAutoTask{}).Select("invalid").Where("auto_task_id = ?", autoTaskId).First(&Invalid)
		//fmt.Println("t:", autoTaskInfo.Invalid)
		db1 := GetReadDB(context.Background())
		project := gorm_model.ProjectInfo{}
		db1.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectId).First(&project)
		//if project.AutoFailAt.IsZero() {
		//	dd, _ := time.ParseDuration(conv.MustString(Invalid, "") + "h")
		//	t := project.RecruitDdl.Add(dd)
		//	db2 := GetReadDB(context.Background())
		//	db2.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectId).Updates(&gorm_model.ProjectInfo{AutoFailAt: &t})
		//	fmt.Println("已添加失效自动处理时间")
		//}

		dd, _ := time.ParseDuration(conv.MustString(Invalid, "") + "h")
		project.RecruitDdl.Add(dd)
		t := project.RecruitDdl.Add(dd)
		if project.AutoFailAt != &t {
			db3 := GetReadDB(context.Background())
			db3.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectId).Updates(&gorm_model.ProjectInfo{AutoFailAt: &t})
			fmt.Println("已添加失效自动处理时间")
		}

		projectNeedMod := gorm_model.ProjectInfo{}
		db2 := GetReadDB(context.Background())
		db2.Where("project_id = ?", projectId).First(&projectNeedMod)
		if !projectNeedMod.AutoFailAt.IsZero() {
			if projectNeedMod.AutoFailAt.Sub(time.Now()) <= 0 && projectNeedMod.ProjectStatus < 8 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectId).Updates(&gorm_model.ProjectInfo{ProjectStatus: 8, FailReason: 1}).Error
				if err1 != nil {
					return err1
				}
				fmt.Println("已更新项目状态")
			}
		}
	}
	return nil
}

func GetAutoDraftDefaultInPicTask() error {
	db := GetReadDB(context.Background())
	var projectInfos []*gorm_model.ProjectInfo
	err := db.Model(gorm_model.ProjectInfo{}).Where("project_type = ? AND content_type = ? ", 1, 1).Find(&projectInfos).Error
	if err != nil {
		return err
	}
	// 项目类型为 实体商品寄拍、虚拟产品测评、线下探店打卡 均为正常的 收发货情况，以签收状况作为判断条件
	var projectIds []int64
	// 存储素材微原创的项目id，此情况单独处理，它不涉及到物流，也不涉及到脚本，初稿上一个状态直接就是支付。
	var specialProjectIds []int64
	projectIdToAutoTaskIdMap := map[int64]int{}
	// 项目id 对 违约定时任务id 的map
	projectIdToAutoDefaultIdMap := map[int64]int{}
	// taskId 对 稿费形式的 map
	taskIdToFeeFormMap := make(map[int]int)
	TaskIdToProjectId := make(map[int]int)
	var taskNeedModIds []int
	var specialTaskNeedModIds []int
	// 已提交初稿的任务记录id
	var submitTaskNeedModIds []int
	for _, projectInfo := range projectInfos {
		if projectInfo.ProjectForm == 4 {
			specialProjectIds = append(specialProjectIds, projectInfo.ProjectID)
			specialProjectInfo := gorm_model.ProjectInfo{}
			db1 := GetReadDB(context.Background())
			db1.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectInfo.ProjectID).First(&specialProjectInfo)
			dbStart := GetReadDB(context.Background())
			var DraftDefaultInPic int32
			dbStart.Model(gorm_model.InfoAutoTask{}).Select("draft_default_in_pic").Where("auto_task_id = ?", specialProjectInfo.AutoTaskID).First(&DraftDefaultInPic)
			dd, _ := time.ParseDuration(conv.MustString(DraftDefaultInPic, "") + "h")
			t1 := projectInfo.PayAt.Add(dd)
			if !projectInfo.PayAt.IsZero() && projectInfo.AutoSketchBreakAt.IsZero() {
				db1.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectInfo.ProjectID).Updates(&gorm_model.ProjectInfo{AutoSketchBreakAt: &t1})
				fmt.Println("已添加素材微原创的初稿违约自动处理时间")
			}
		} else {
			projectIds = append(projectIds, projectInfo.ProjectID)
		}
		projectIdToAutoTaskIdMap[projectInfo.ProjectID] = int(projectInfo.AutoTaskID)
		projectIdToAutoDefaultIdMap[projectInfo.ProjectID] = int(projectInfo.AutoDefaultID)
	}
	//fmt.Println("projectIds:", projectIds)
	//fmt.Println("specialProjectIds:", specialProjectIds)
	for _, specialProjectId := range specialProjectIds {
		db2 := GetReadDB(context.Background())
		var taskInfos []gorm_model.YoungeeTaskInfo
		db2.Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND cur_default_type = ?", specialProjectId, 0).Find(&taskInfos)
		for _, taskInfo := range taskInfos {
			TaskIdToProjectId[taskInfo.TaskId] = int(specialProjectId)
			taskIdToFeeFormMap[taskInfo.TaskId] = taskInfo.FeeForm
			specialTaskNeedMod := gorm_model.YoungeeTaskInfo{}
			db3 := GetReadDB(context.Background())
			// 保存所有初稿上传状态为 1或 3 的任务记录的id
			db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskInfo.TaskId).First(&specialTaskNeedMod)
			if specialTaskNeedMod.SketchStatus == 1 && taskInfo.TaskStage == 10 {
				specialTaskNeedModIds = append(specialTaskNeedModIds, taskInfo.TaskId)
			}
			if specialTaskNeedMod.SketchStatus == 3 && taskInfo.TaskStage == 10 {
				submitTaskNeedModIds = append(submitTaskNeedModIds, taskInfo.TaskId)
			}
		}
	}
	//fmt.Println("specialTaskNeedModIds:", specialTaskNeedModIds)
	for _, specialTaskNeedModId := range specialTaskNeedModIds {
		projectNeedMod := gorm_model.ProjectInfo{}
		db1 := GetReadDB(context.Background())
		db1.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", TaskIdToProjectId[specialTaskNeedModId]).First(&projectNeedMod)
		var sketchDefaultRate int
		if taskIdToFeeFormMap[specialTaskNeedModId] == 1 {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("script_replace_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[int64(TaskIdToProjectId[specialTaskNeedModId])]).Find(&sketchDefaultRate)
		} else {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("script_other_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[int64(TaskIdToProjectId[specialTaskNeedModId])]).Find(&sketchDefaultRate)
		}
		if projectNeedMod.AutoSketchBreakAt.Sub(time.Now()) <= 0 && !projectNeedMod.AutoSketchBreakAt.IsZero() {
			db2 := GetReadDB(context.Background())
			err1 := db2.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
				TaskID: specialTaskNeedModId, ProjectID: TaskIdToProjectId[specialTaskNeedModId], BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
			if err1 != nil {
				return err1
			}
			db3 := GetReadDB(context.Background())
			db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", specialTaskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{CurDefaultType: 3, SketchBreakRate: sketchDefaultRate})
			fmt.Println("已创建素材微原创的任务初稿违约记录")
		}
	}
	for _, projectId := range projectIds {
		db1 := GetReadDB(context.Background())
		var taskInfos []gorm_model.YoungeeTaskInfo
		db1.Model(gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND cur_default_type = ? ", projectId, 0).Find(&taskInfos)
		for _, taskInfo := range taskInfos {
			TaskIdToProjectId[taskInfo.TaskId] = int(projectId)
			taskNeedMod := gorm_model.YoungeeTaskInfo{}
			db2 := GetReadDB(context.Background())
			// 保存所有满足物流状态为3 且 初稿上传状态为 1或 3 的任务记录的id
			db2.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskInfo.TaskId).First(&taskNeedMod)
			if taskNeedMod.LogisticsStatus == 3 && taskNeedMod.ScriptStatus == 1 {
				taskNeedModIds = append(taskNeedModIds, taskInfo.TaskId)
			}
			if taskNeedMod.LogisticsStatus == 3 && taskNeedMod.ScriptStatus == 3 {
				submitTaskNeedModIds = append(submitTaskNeedModIds, taskInfo.TaskId)
			}
		}
	}
	//fmt.Println("projectIdToAutoTaskIdMap:", projectIdToAutoTaskIdMap)
	//fmt.Println("TaskIdToProjectId:", TaskIdToProjectId)
	//fmt.Println("taskNeedModIds:", taskNeedModIds)
	for _, taskNeedModId := range taskNeedModIds {
		// 获取 autoTaskId 及其对应的限制时间、
		//fmt.Println("taskNeedModId:", taskNeedModId)
		autoTaskId := projectIdToAutoTaskIdMap[int64(TaskIdToProjectId[taskNeedModId])]
		dbStart := GetReadDB(context.Background())
		var DraftDefaultInPic int32
		dbStart.Model(gorm_model.InfoAutoTask{}).Select("draft_default_in_pic").Where("auto_task_id = ?", autoTaskId).First(&DraftDefaultInPic)
		//fmt.Println("t:", autoTaskInfo.DraftDefaultInPic)
		db3 := GetReadDB(context.Background())
		taskLogisticNeedMod := gorm_model.YoungeeTaskLogistics{}
		db3.Model(gorm_model.YoungeeTaskLogistics{}).Where("task_id = ?", taskNeedModId).First(&taskLogisticNeedMod)
		var sketchDefaultRate int
		if taskIdToFeeFormMap[taskNeedModId] == 1 {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("script_replace_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[int64(TaskIdToProjectId[taskNeedModId])]).Find(&sketchDefaultRate)
		} else {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("script_other_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[int64(TaskIdToProjectId[taskNeedModId])]).Find(&sketchDefaultRate)
		}
		if taskLogisticNeedMod.AutoSketchBreakAt.IsZero() {
			dd, _ := time.ParseDuration(conv.MustString(DraftDefaultInPic, "") + "h")
			db4 := GetReadDB(context.Background())
			logisticNeedMod := gorm_model.YoungeeTaskLogistics{}
			db4.Model(gorm_model.YoungeeTaskLogistics{}).Where("task_id = ?", taskNeedModId).First(&logisticNeedMod)
			if logisticNeedMod.ThingsType == 1 && !logisticNeedMod.SignedTime.IsZero() {
				db4.Where("task_id = ?", taskNeedModId).Updates(&gorm_model.YoungeeTaskLogistics{
					AutoSketchBreakAt: taskLogisticNeedMod.SignedTime.Add(dd),
				})
				fmt.Println("已添加实物的图片初稿违约自动处理时间")
			}
			if logisticNeedMod.ThingsType != 1 && !logisticNeedMod.AutoSignAt.IsZero() {
				db4.Where("task_id = ?", taskNeedModId).Updates(&gorm_model.YoungeeTaskLogistics{
					AutoSketchBreakAt: taskLogisticNeedMod.AutoSignAt.Add(dd),
				})
				fmt.Println("已添加虚拟产品及线下探店的图片初稿违约自动处理时间")
			}
		}
		db7 := GetReadDB(context.Background())
		taskLogisticNeedMod2 := gorm_model.YoungeeTaskLogistics{}
		db7.Model(gorm_model.YoungeeTaskLogistics{}).Where("task_id = ?", taskNeedModId).First(&taskLogisticNeedMod2)
		if !taskLogisticNeedMod2.AutoSketchBreakAt.IsZero() && taskLogisticNeedMod2.AutoSketchBreakAt.Sub(time.Now()) <= 0 {
			db5 := GetReadDB(context.Background())
			err1 := db5.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
				TaskID: taskNeedModId, ProjectID: TaskIdToProjectId[taskNeedModId], BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
			if err1 != nil {
				return err1
			}
			db8 := GetReadDB(context.Background())
			db8.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskLogisticNeedMod2.TaskID).Updates(&gorm_model.YoungeeTaskInfo{CurDefaultType: 3, SketchBreakRate: sketchDefaultRate})
			fmt.Println("已创建图文类型的初稿违约记录")
		}
	}
	for _, submitTaskNeedModId := range submitTaskNeedModIds {
		db2 := GetReadDB(context.Background())
		var DraftDefaultInMv int32
		db2.Model(&gorm_model.InfoAutoTask{}).Select("draft_default_in_mv").Where("auto_task_id = ?", projectIdToAutoTaskIdMap[int64(TaskIdToProjectId[submitTaskNeedModId])]).First(&DraftDefaultInMv)
		dd, _ := time.ParseDuration(conv.MustString(DraftDefaultInMv, "") + "h")
		var sketchDefaultRate int
		if taskIdToFeeFormMap[submitTaskNeedModId] == 1 {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("script_replace_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[int64(TaskIdToProjectId[submitTaskNeedModId])]).Find(&sketchDefaultRate)
		} else {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("script_other_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[int64(TaskIdToProjectId[submitTaskNeedModId])]).Find(&sketchDefaultRate)
		}
		db1 := GetReadDB(context.Background())
		var taskSketchInfo gorm_model.YounggeeSketchInfo
		db1.Model(gorm_model.YounggeeSketchInfo{}).Where("task_id = ?", submitTaskNeedModId).Order("reject_at desc").First(&taskSketchInfo)
		if taskSketchInfo.AutoSketchBreakAt.IsZero() {
			err4 := db1.Where("task_id = ?", submitTaskNeedModId).Updates(&gorm_model.YounggeeSketchInfo{AutoSketchBreakAt: taskSketchInfo.RejectAt.Add(dd)}).Error
			if err4 != nil {
				return err4
			}
			fmt.Println("已添加图文形式的初稿违约自动处理时间")
			if taskSketchInfo.RejectAt.Add(dd).Sub(time.Now()) <= 0 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
					TaskID: submitTaskNeedModId, ProjectID: TaskIdToProjectId[submitTaskNeedModId], BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
				if err1 != nil {
					return err1
				}
				db3 := GetReadDB(context.Background())
				err2 := db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", submitTaskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{CurDefaultType: 3, SketchBreakRate: sketchDefaultRate}).Error
				if err2 != nil {
					return err2
				}
				fmt.Println("创建时已违约则创建已提交初稿的图文类型的初稿违约记录")
			}
		} else {
			if taskSketchInfo.AutoSketchBreakAt.Sub(time.Now()) <= 0 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
					TaskID: submitTaskNeedModId, ProjectID: TaskIdToProjectId[submitTaskNeedModId], BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
				if err1 != nil {
					return err1
				}
				db3 := GetReadDB(context.Background())
				err2 := db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", submitTaskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{CurDefaultType: 3, SketchBreakRate: sketchDefaultRate}).Error
				if err2 != nil {
					return err2
				}
				fmt.Println("创建已提交初稿的图文类型的初稿违约记录")
			}
		}
	}
	return nil
}

func GetAutoDraftDefaultInMvTask() error {
	db := GetReadDB(context.Background())
	var VideoProjectIds []int64
	err := db.Select("project_id").Model(gorm_model.ProjectInfo{}).Where("project_type = ? AND content_type = ? ", 1, 2).Find(&VideoProjectIds).Error
	if err != nil {
		return err
	}
	//fmt.Println("VideoProjectIds:", VideoProjectIds)
	// 任务id 对 项目id 的map
	taskIdToProjectIdMap := map[int]int64{}
	// 项目id 对 定时任务id 的map
	projectIdToAutoTaskIdMap := map[int64]int{}
	// 项目id 对 违约定时任务id 的map
	projectIdToAutoDefaultIdMap := map[int64]int{}
	// taskId 对 稿费形式的 map
	taskIdToFeeFormMap := make(map[int]int)
	var videoTaskIds []int
	for _, VideoProjectId := range VideoProjectIds {
		db2 := GetReadDB(context.Background())
		autoIds := gorm_model.ProjectInfo{}
		db2.Select([]string{"auto_task_id", "auto_default_id"}).Model(&gorm_model.ProjectInfo{}).Where("project_id = ?", VideoProjectId).First(&autoIds)
		projectIdToAutoTaskIdMap[VideoProjectId] = int(autoIds.AutoTaskID)
		projectIdToAutoDefaultIdMap[VideoProjectId] = int(autoIds.AutoDefaultID)

		var videoTaskInfos []*gorm_model.YoungeeTaskInfo
		db1 := GetReadDB(context.Background())
		db1.Model(&gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND cur_default_type = ? ", VideoProjectId, 0).Find(&videoTaskInfos)
		for _, videoTaskInfo := range videoTaskInfos {
			taskIdToProjectIdMap[videoTaskInfo.TaskId] = VideoProjectId
			taskIdToFeeFormMap[videoTaskInfo.TaskId] = videoTaskInfo.FeeForm
			videoTaskIds = append(videoTaskIds, videoTaskInfo.TaskId)
		}
	}
	//fmt.Println("taskIdToProjectIdMap:", taskIdToProjectIdMap)
	//fmt.Println("projectIdToAutoTaskIdMap:", projectIdToAutoTaskIdMap)
	//fmt.Println("videoTaskIds:", videoTaskIds)
	// 首次提交初稿的任务记录id
	var videoTaskNeedModIds []int
	// 已提交初稿的任务记录id
	var submitVideoTaskNeedModIds []int
	for _, videoTaskId := range videoTaskIds {
		var taskInfo gorm_model.YoungeeTaskInfo
		db3 := GetReadDB(context.Background())
		// 保存所有初稿上传状态为 1  且任务状态为10 的任务记录的id
		db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", videoTaskId).First(&taskInfo)
		if taskInfo.SketchStatus == 1 && taskInfo.TaskStage == 10 {
			videoTaskNeedModIds = append(videoTaskNeedModIds, videoTaskId)
		}
		// 保存所有初稿上传状态为 3  且任务状态为10 的任务记录的id
		if taskInfo.SketchStatus == 3 && taskInfo.TaskStage == 10 {
			submitVideoTaskNeedModIds = append(submitVideoTaskNeedModIds, videoTaskId)
		}
	}
	//fmt.Println("videoTaskNeedModIds:", videoTaskNeedModIds)
	//fmt.Println("submitVideoTaskNeedModIds:", submitVideoTaskNeedModIds)
	for _, videoTaskNeedModId := range videoTaskNeedModIds {
		db2 := GetReadDB(context.Background())
		var DraftDefaultInMv int32
		db2.Model(&gorm_model.InfoAutoTask{}).Select("draft_default_in_mv").Where("auto_task_id = ?", projectIdToAutoTaskIdMap[taskIdToProjectIdMap[videoTaskNeedModId]]).First(&DraftDefaultInMv)
		dd, _ := time.ParseDuration(conv.MustString(DraftDefaultInMv, "") + "h")
		var sketchDefaultRate int
		if taskIdToFeeFormMap[videoTaskNeedModId] == 1 {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("script_replace_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[taskIdToProjectIdMap[videoTaskNeedModId]]).Find(&sketchDefaultRate)
		} else {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("script_other_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[taskIdToProjectIdMap[videoTaskNeedModId]]).Find(&sketchDefaultRate)
		}
		db1 := GetReadDB(context.Background())
		var taskScriptInfo gorm_model.YounggeeScriptInfo
		db1.Model(gorm_model.YounggeeScriptInfo{}).Where("task_id = ? AND is_ok = ?", videoTaskNeedModId, 1).Find(&taskScriptInfo)
		if taskScriptInfo.AutoSketchBreakAt.IsZero() {
			db1.Where("task_id = ?", videoTaskNeedModId).Updates(&gorm_model.YounggeeScriptInfo{AutoSketchBreakAt: taskScriptInfo.AutoAgreeAt.Add(dd)})
			fmt.Println("已添加视频形式的初稿违约自动处理时间")
			if taskScriptInfo.AutoAgreeAt.Add(dd).Sub(time.Now()) <= 0 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
					TaskID: videoTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[videoTaskNeedModId]), BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
				if err1 != nil {
					return err1
				}
				db3 := GetReadDB(context.Background())
				err2 := db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", videoTaskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{CurDefaultType: 3, SketchBreakRate: sketchDefaultRate}).Error
				if err2 != nil {
					return err2
				}
				fmt.Println("创建时已违约则创建视频类型的初稿违约记录")
			}
		} else {
			if taskScriptInfo.AutoSketchBreakAt.Sub(time.Now()) <= 0 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
					TaskID: videoTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[videoTaskNeedModId]), BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
				if err1 != nil {
					return err1
				}
				db3 := GetReadDB(context.Background())
				err2 := db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", videoTaskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{CurDefaultType: 3, SketchBreakRate: sketchDefaultRate}).Error
				if err2 != nil {
					return err2
				}
				fmt.Println("已创建视频类型的初稿违约记录")
			}
		}
	}
	for _, submitVideoTaskNeedModId := range submitVideoTaskNeedModIds {
		db2 := GetReadDB(context.Background())
		var DraftDefaultInMv int32
		db2.Model(&gorm_model.InfoAutoTask{}).Select("draft_default_in_mv").Where("auto_task_id = ?", projectIdToAutoTaskIdMap[taskIdToProjectIdMap[submitVideoTaskNeedModId]]).First(&DraftDefaultInMv)
		dd, _ := time.ParseDuration(conv.MustString(DraftDefaultInMv, "") + "h")
		var sketchDefaultRate int
		if taskIdToFeeFormMap[submitVideoTaskNeedModId] == 1 {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("script_replace_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[taskIdToProjectIdMap[submitVideoTaskNeedModId]]).Find(&sketchDefaultRate)
		} else {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("script_other_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[taskIdToProjectIdMap[submitVideoTaskNeedModId]]).Find(&sketchDefaultRate)
		}
		db1 := GetReadDB(context.Background())
		var taskSketchInfo gorm_model.YounggeeSketchInfo
		db1.Model(gorm_model.YounggeeSketchInfo{}).Where("task_id = ?", submitVideoTaskNeedModId).Order("reject_at desc").First(&taskSketchInfo)
		if taskSketchInfo.AutoSketchBreakAt.IsZero() {
			err4 := db1.Where("task_id = ?", submitVideoTaskNeedModId).Updates(&gorm_model.YounggeeSketchInfo{AutoSketchBreakAt: taskSketchInfo.RejectAt.Add(dd)}).Error
			if err4 != nil {
				return err4
			}
			fmt.Println("已添加视频形式的初稿违约自动处理时间")
			if taskSketchInfo.RejectAt.Add(dd).Sub(time.Now()) <= 0 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
					TaskID: submitVideoTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[submitVideoTaskNeedModId]), BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
				if err1 != nil {
					return err1
				}
				db3 := GetReadDB(context.Background())
				err2 := db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", submitVideoTaskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{CurDefaultType: 3, SketchBreakRate: sketchDefaultRate}).Error
				if err2 != nil {
					return err2
				}
				fmt.Println("创建时已违约则创建已提交初稿的视频类型的初稿违约记录")
			}
		} else {
			if taskSketchInfo.AutoSketchBreakAt.Sub(time.Now()) <= 0 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
					TaskID: submitVideoTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[submitVideoTaskNeedModId]), BreakType: 2, BreakAt: time.Now(), DefaultStatus: 1}).Error
				if err1 != nil {
					return err1
				}
				db3 := GetReadDB(context.Background())
				err2 := db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", submitVideoTaskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{CurDefaultType: 3, SketchBreakRate: sketchDefaultRate}).Error
				if err2 != nil {
					return err2
				}
				fmt.Println("创建已提交初稿的视频类型的初稿违约记录")
			}
		}
	}
	return nil
}

func GetAutoScriptDefaultTask() error {
	db := GetReadDB(context.Background())
	var VideoProjectIds []int64
	var specialProjectIds []int
	err := db.Select("project_id").Model(gorm_model.ProjectInfo{}).Where("project_type = ? AND content_type = ? AND project_form != 4", 1, 2).Find(&VideoProjectIds).Error
	if err != nil {
		return err
	}
	db.Select("project_id").Model(gorm_model.ProjectInfo{}).Where("project_type = ? AND content_type = ? AND project_form = 4", 1, 2).Find(&specialProjectIds)
	//fmt.Println("VideoProjectIds:", VideoProjectIds)
	//fmt.Println("specialProjectIds:", specialProjectIds)

	// 任务id 对 项目id 的map
	taskIdToProjectIdMap := map[int]int64{}
	// 项目id 对 定时任务id 的map
	projectIdToAutoTaskIdMap := map[int64]int{}
	// 项目id 对 违约定时任务id 的map
	projectIdToAutoDefaultIdMap := map[int64]int{}
	// taskId 对 稿费形式的 map
	taskIdToFeeFormMap := make(map[int]int)
	// 素材微原创的任务id
	var specialVideoTaskIds []int
	// 需要判断是否违约的素材微原创的任务id
	var specialTaskNeedModIds []int
	// 首次提交脚本的任务记录id
	var videoTaskNeedModIds []int
	// 已提交脚本的任务记录id
	var submitVideoTaskNeedModIds []int
	for _, specialProjectId := range specialProjectIds {
		db2 := GetReadDB(context.Background())
		var projectInfo gorm_model.ProjectInfo
		db2.Model(&gorm_model.ProjectInfo{}).Where("project_id = ?", specialProjectId).First(&projectInfo)
		projectIdToAutoTaskIdMap[int64(specialProjectId)] = int(projectInfo.AutoTaskID)
		projectIdToAutoDefaultIdMap[int64(specialProjectId)] = int(projectInfo.AutoDefaultID)
		var ScriptDefault int32
		dbStart := GetReadDB(context.Background())
		dbStart.Model(gorm_model.InfoAutoTask{}).Select("script_default").Where("auto_task_id = ?", projectInfo.AutoTaskID).First(&ScriptDefault)
		dd, _ := time.ParseDuration(conv.MustString(ScriptDefault, "") + "h")
		t3 := projectInfo.PayAt.Add(dd)
		if !projectInfo.PayAt.IsZero() && projectInfo.AutoScriptBreakAt.IsZero() {
			db1 := GetReadDB(context.Background())
			db1.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", projectInfo.ProjectID).Updates(&gorm_model.ProjectInfo{AutoScriptBreakAt: &t3})
			fmt.Println("已添加素材微原创的脚本违约自动处理时间")
		}
		var videoTaskInfos []*gorm_model.YoungeeTaskInfo
		db1 := GetReadDB(context.Background())
		db1.Model(&gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND cur_default_type = ? ", specialProjectId, 0).Find(&videoTaskInfos)
		for _, videoTaskInfo := range videoTaskInfos {
			taskIdToProjectIdMap[videoTaskInfo.TaskId] = int64(specialProjectId)
			specialVideoTaskIds = append(specialVideoTaskIds, videoTaskInfo.TaskId)
			specialTaskNeedMod := gorm_model.YoungeeTaskInfo{}
			db3 := GetReadDB(context.Background())
			// 保存所有脚本上传状态为 1  且任务状态为8 的任务记录的id
			db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", videoTaskInfo.TaskId).First(&specialTaskNeedMod)
			if specialTaskNeedMod.ScriptStatus == 1 && specialTaskNeedMod.TaskStage == 8 {
				specialTaskNeedModIds = append(specialTaskNeedModIds, videoTaskInfo.TaskId)
			}
			// 保存所有脚本上传状态为 3  且任务状态为8 的任务记录的id
			if specialTaskNeedMod.ScriptStatus == 3 && specialTaskNeedMod.TaskStage == 8 {
				submitVideoTaskNeedModIds = append(submitVideoTaskNeedModIds, videoTaskInfo.TaskId)
			}
			taskIdToFeeFormMap[videoTaskInfo.TaskId] = videoTaskInfo.FeeForm
		}
	}
	//fmt.Println("submitVideoTaskNeedModIds:", submitVideoTaskNeedModIds)
	//fmt.Println("specialTaskNeedModIds:", specialTaskNeedModIds)
	for _, specialTaskNeedModId := range specialTaskNeedModIds {
		projectNeedMod := gorm_model.ProjectInfo{}
		db1 := GetReadDB(context.Background())
		db1.Model(gorm_model.ProjectInfo{}).Where("project_id = ?", taskIdToProjectIdMap[specialTaskNeedModId]).First(&projectNeedMod)
		if projectNeedMod.AutoScriptBreakAt.Sub(time.Now()) <= 0 && !projectNeedMod.AutoScriptBreakAt.IsZero() {
			var scriptDefaultRate int
			if taskIdToFeeFormMap[specialTaskNeedModId] == 1 {
				db6 := GetReadDB(context.Background())
				db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("script_replace_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[taskIdToProjectIdMap[specialTaskNeedModId]]).Find(&scriptDefaultRate)
			} else {
				db6 := GetReadDB(context.Background())
				db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("script_other_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[taskIdToProjectIdMap[specialTaskNeedModId]]).Find(&scriptDefaultRate)
			}
			db2 := GetReadDB(context.Background())
			err1 := db2.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
				TaskID: specialTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[specialTaskNeedModId]), BreakType: 1, BreakAt: time.Now(), DefaultStatus: 1}).Error
			if err1 != nil {
				return err1
			}
			db3 := GetReadDB(context.Background())
			db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", specialTaskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{CurDefaultType: 1, ScriptBreakRate: scriptDefaultRate})
			fmt.Println("已创建素材微原创的任务脚本违约记录")
		}
	}
	var videoTaskIds []int
	for _, VideoProjectId := range VideoProjectIds {
		db2 := GetReadDB(context.Background())
		var autoTaskId int
		db2.Select("auto_task_id").Model(&gorm_model.ProjectInfo{}).Where("project_id = ?", VideoProjectId).First(&autoTaskId)
		projectIdToAutoTaskIdMap[VideoProjectId] = autoTaskId
		var videoTaskInfos []*gorm_model.YoungeeTaskInfo
		db1 := GetReadDB(context.Background())
		db1.Model(&gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND cur_default_type = ? ", VideoProjectId, 0).Find(&videoTaskInfos)
		for _, videoTaskInfo := range videoTaskInfos {
			taskIdToProjectIdMap[videoTaskInfo.TaskId] = VideoProjectId
			videoTaskIds = append(videoTaskIds, videoTaskInfo.TaskId)
		}
	}
	//fmt.Println("taskIdToProjectIdMap:", taskIdToProjectIdMap)
	//fmt.Println("projectIdToAutoTaskIdMap:", projectIdToAutoTaskIdMap)
	//fmt.Println("videoTaskIds:", videoTaskIds)
	for _, videoTaskId := range videoTaskIds {
		var taskInfo gorm_model.YoungeeTaskInfo
		db3 := GetReadDB(context.Background())
		// 保存所有脚本上传状态为 1  且任务状态为8 的任务记录的id
		db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", videoTaskId).First(&taskInfo)
		if taskInfo.ScriptStatus == 1 && taskInfo.TaskStage == 8 {
			videoTaskNeedModIds = append(videoTaskNeedModIds, videoTaskId)
		}
		// 保存所有脚本上传状态为 3  且任务状态为8 的任务记录的id
		if taskInfo.ScriptStatus == 3 && taskInfo.TaskStage == 8 {
			submitVideoTaskNeedModIds = append(submitVideoTaskNeedModIds, videoTaskId)
		}
	}
	//fmt.Println("videoTaskNeedModIds:", videoTaskNeedModIds)
	//fmt.Println("submitVideoTaskNeedModIds:", submitVideoTaskNeedModIds)
	for _, videoTaskNeedModId := range videoTaskNeedModIds {
		db2 := GetReadDB(context.Background())
		var ScriptDefault int32
		db2.Model(&gorm_model.InfoAutoTask{}).Select("script_default").Where("auto_task_id = ?", projectIdToAutoTaskIdMap[taskIdToProjectIdMap[videoTaskNeedModId]]).First(&ScriptDefault)
		dd, _ := time.ParseDuration(conv.MustString(ScriptDefault, "") + "h")
		db1 := GetReadDB(context.Background())
		var taskLogisticInfo gorm_model.YoungeeTaskLogistics
		db1.Model(gorm_model.YoungeeTaskLogistics{}).Where("task_id = ?", videoTaskNeedModId).Find(&taskLogisticInfo)
		var scriptDefaultRate int
		if taskIdToFeeFormMap[videoTaskNeedModId] == 1 {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("script_replace_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[taskIdToProjectIdMap[videoTaskNeedModId]]).Find(&scriptDefaultRate)
		} else {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("script_other_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[taskIdToProjectIdMap[videoTaskNeedModId]]).Find(&scriptDefaultRate)
		}
		if taskLogisticInfo.AutoScriptBreakAt.IsZero() {
			db1.Where("task_id = ?", videoTaskNeedModId).Updates(&gorm_model.YoungeeTaskLogistics{AutoScriptBreakAt: taskLogisticInfo.AutoSignAt.Add(dd)})
			fmt.Println("已添加视频形式的脚本违约自动处理时间")
			if taskLogisticInfo.AutoSignAt.Add(dd).Sub(time.Now()) <= 0 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
					TaskID: videoTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[videoTaskNeedModId]), BreakType: 1, BreakAt: time.Now(), DefaultStatus: 1}).Error
				if err1 != nil {
					return err1
				}
				db3 := GetReadDB(context.Background())
				err2 := db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", videoTaskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{CurDefaultType: 1, ScriptBreakRate: scriptDefaultRate}).Error
				if err2 != nil {
					return err2
				}
				fmt.Println("创建时已违约则创建视频类型的脚本违约记录")
			}
		} else {
			if taskLogisticInfo.AutoScriptBreakAt.Sub(time.Now()) <= 0 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
					TaskID: videoTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[videoTaskNeedModId]), BreakType: 1, BreakAt: time.Now(), DefaultStatus: 1}).Error
				if err1 != nil {
					return err1
				}
				db3 := GetReadDB(context.Background())
				err2 := db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", videoTaskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{CurDefaultType: 1, ScriptBreakRate: scriptDefaultRate}).Error
				if err2 != nil {
					return err2
				}
				fmt.Println("已创建视频类型的脚本违约记录")
			}
		}
	}
	// 根据最近一次拒绝时间判断当前是否违约
	for _, submitVideoTaskNeedModId := range submitVideoTaskNeedModIds {
		db2 := GetReadDB(context.Background())
		var ScriptDefault int32
		db2.Model(&gorm_model.InfoAutoTask{}).Select("script_default").Where("auto_task_id = ?", projectIdToAutoTaskIdMap[taskIdToProjectIdMap[submitVideoTaskNeedModId]]).First(&ScriptDefault)
		dd, _ := time.ParseDuration(conv.MustString(ScriptDefault, "") + "h")
		db1 := GetReadDB(context.Background())
		var taskScriptInfo gorm_model.YounggeeScriptInfo
		db1.Model(gorm_model.YounggeeScriptInfo{}).Where("task_id = ?", submitVideoTaskNeedModId).Order("reject_at desc").First(&taskScriptInfo)
		var scriptDefaultRate int
		if taskIdToFeeFormMap[submitVideoTaskNeedModId] == 1 {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("script_replace_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[taskIdToProjectIdMap[submitVideoTaskNeedModId]]).Find(&scriptDefaultRate)
		} else {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("script_other_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[taskIdToProjectIdMap[submitVideoTaskNeedModId]]).Find(&scriptDefaultRate)
		}
		if taskScriptInfo.AutoScriptBreakAt.IsZero() {
			err4 := db1.Where("task_id = ?", submitVideoTaskNeedModId).Updates(&gorm_model.YounggeeScriptInfo{AutoScriptBreakAt: taskScriptInfo.RejectAt.Add(dd)}).Error
			if err4 != nil {
				return err4
			}
			fmt.Println("已添加视频形式的脚本违约自动处理时间")
			if taskScriptInfo.RejectAt.Add(dd).Sub(time.Now()) <= 0 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
					TaskID: submitVideoTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[submitVideoTaskNeedModId]), BreakType: 1, BreakAt: time.Now(), DefaultStatus: 1}).Error
				if err1 != nil {
					return err1
				}
				db3 := GetReadDB(context.Background())
				err2 := db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", submitVideoTaskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{
					CurDefaultType: 1, ScriptBreakRate: scriptDefaultRate}).Error
				if err2 != nil {
					return err2
				}
				fmt.Println("创建时已违约则创建已提交脚本的视频类型的脚本违约记录")
			}
		} else {
			if taskScriptInfo.AutoScriptBreakAt.Sub(time.Now()) <= 0 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
					TaskID: submitVideoTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[submitVideoTaskNeedModId]), BreakType: 1, BreakAt: time.Now(), DefaultStatus: 1}).Error
				if err1 != nil {
					return err1
				}
				db3 := GetReadDB(context.Background())
				err2 := db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", submitVideoTaskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{
					CurDefaultType: 1, ScriptBreakRate: scriptDefaultRate}).Error
				if err2 != nil {
					return err2
				}
				fmt.Println("创建已提交脚本的视频类型的脚本违约记录")
			}
		}
	}
	return nil
}

func GetAutoLinkBreachTask() error {
	db := GetReadDB(context.Background())
	var projectIds []int64
	err := db.Select("project_id").Model(gorm_model.ProjectInfo{}).Where("project_type = ?", 1).Find(&projectIds).Error
	if err != nil {
		return err
	}
	//fmt.Println("projectIds:", projectIds)
	// 任务id 对 项目id 的map
	taskIdToProjectIdMap := map[int]int64{}
	// 项目id 对 定时任务id 的map
	projectIdToAutoTaskIdMap := map[int64]int{}
	// 项目id 对 违约定时任务id 的map
	projectIdToAutoDefaultIdMap := map[int64]int{}
	var taskIds []int
	// taskId 对 稿费形式的 map
	taskIdToFeeFormMap := make(map[int]int)
	for _, projectId := range projectIds {
		db2 := GetReadDB(context.Background())
		autoIds := gorm_model.ProjectInfo{}
		db2.Select([]string{"auto_task_id", "auto_default_id"}).Model(&gorm_model.ProjectInfo{}).Where("project_id = ?", projectId).First(&autoIds)
		projectIdToAutoTaskIdMap[projectId] = int(autoIds.AutoTaskID)
		projectIdToAutoDefaultIdMap[projectId] = int(autoIds.AutoDefaultID)
		var taskInfos []*gorm_model.YoungeeTaskInfo
		db1 := GetReadDB(context.Background())
		db1.Model(&gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND cur_default_type = ? ", projectId, 0).Find(&taskInfos)
		for _, taskInfo := range taskInfos {
			taskIdToProjectIdMap[taskInfo.TaskId] = projectId
			taskIds = append(taskIds, taskInfo.TaskId)
			taskIdToFeeFormMap[taskInfo.TaskId] = taskInfo.FeeForm
		}
	}
	//fmt.Println("taskIdToProjectIdMap:", taskIdToProjectIdMap)
	//fmt.Println("taskIds:", taskIds)
	// 首次提交链接的任务记录id
	var taskNeedModIds []int
	// 已提交链接的任务记录id
	var submitTaskNeedModIds []int
	for _, taskId := range taskIds {
		var taskInfo gorm_model.YoungeeTaskInfo
		db3 := GetReadDB(context.Background())
		// 保存所有链接上传状态为 1  且任务状态为12 的任务记录的id
		db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskId).First(&taskInfo)
		if taskInfo.LinkStatus == 1 && taskInfo.TaskStage == 12 {
			taskNeedModIds = append(taskNeedModIds, taskId)
		}
		// 保存所有链接上传状态为 3  且任务状态为12 的任务记录的id
		if taskInfo.LinkStatus == 3 && taskInfo.TaskStage == 12 {
			submitTaskNeedModIds = append(submitTaskNeedModIds, taskId)
		}
	}
	//fmt.Println("taskNeedModIds:", taskNeedModIds)
	//fmt.Println("submitTaskNeedModIds:", submitTaskNeedModIds)
	for _, taskNeedModId := range taskNeedModIds {
		db2 := GetReadDB(context.Background())
		var linkBreach int32
		db2.Model(&gorm_model.InfoAutoTask{}).Select("link_breach").Where("auto_task_id = ?", projectIdToAutoTaskIdMap[taskIdToProjectIdMap[taskNeedModId]]).First(&linkBreach)
		dd, _ := time.ParseDuration(conv.MustString(linkBreach, "") + "h")
		var linkDefaultRate int
		if taskIdToFeeFormMap[taskNeedModId] == 1 {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("link_replace_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[taskIdToProjectIdMap[taskNeedModId]]).Find(&linkDefaultRate)
		} else {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("link_other_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[taskIdToProjectIdMap[taskNeedModId]]).Find(&linkDefaultRate)
		}
		db1 := GetReadDB(context.Background())
		var taskSketchInfo gorm_model.YounggeeSketchInfo
		db1.Model(gorm_model.YounggeeSketchInfo{}).Where("task_id = ? AND is_ok = ?", taskNeedModId, 1).Find(&taskSketchInfo)
		if taskSketchInfo.AutoLinkBreakAt.IsZero() {
			db1.Where("task_id = ?", taskNeedModId).Updates(&gorm_model.YounggeeSketchInfo{AutoLinkBreakAt: taskSketchInfo.AutoAgreeAt.Add(dd)})
			fmt.Println("已添加链接违约自动处理时间")
			if taskSketchInfo.AutoAgreeAt.Add(dd).Sub(time.Now()) <= 0 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
					TaskID: taskNeedModId, ProjectID: int(taskIdToProjectIdMap[taskNeedModId]), BreakType: 3, BreakAt: time.Now(), DefaultStatus: 1}).Error
				if err1 != nil {
					return err1
				}
				db3 := GetReadDB(context.Background())
				err2 := db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{CurDefaultType: 5, LinkBreakRate: linkDefaultRate}).Error
				if err2 != nil {
					return err2
				}
				fmt.Println("创建时已违约则创建链接违约记录")
			}
		} else {
			if taskSketchInfo.AutoLinkBreakAt.Sub(time.Now()) <= 0 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
					TaskID: taskNeedModId, ProjectID: int(taskIdToProjectIdMap[taskNeedModId]), BreakType: 3, BreakAt: time.Now(), DefaultStatus: 1}).Error
				if err1 != nil {
					return err1
				}
				db3 := GetReadDB(context.Background())
				err2 := db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{CurDefaultType: 5, LinkBreakRate: linkDefaultRate}).Error
				if err2 != nil {
					return err2
				}
				fmt.Println("已创建链接违约记录")
			}
		}
	}
	// 根据最近一次拒绝时间判断当前是否违约
	for _, submitTaskNeedModId := range submitTaskNeedModIds {
		db2 := GetReadDB(context.Background())
		var LinkBreach int32
		db2.Model(&gorm_model.InfoAutoTask{}).Select("link_breach").Where("auto_task_id = ?", projectIdToAutoTaskIdMap[taskIdToProjectIdMap[submitTaskNeedModId]]).First(&LinkBreach)
		dd, _ := time.ParseDuration(conv.MustString(LinkBreach, "") + "h")
		var linkDefaultRate int
		if taskIdToFeeFormMap[submitTaskNeedModId] == 1 {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("link_replace_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[taskIdToProjectIdMap[submitTaskNeedModId]]).Find(&linkDefaultRate)
		} else {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("link_other_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[taskIdToProjectIdMap[submitTaskNeedModId]]).Find(&linkDefaultRate)
		}
		db1 := GetReadDB(context.Background())
		var taskLinkInfo gorm_model.YounggeeLinkInfo
		db1.Model(gorm_model.YounggeeLinkInfo{}).Where("task_id = ?", submitTaskNeedModId).Order("reject_at desc").First(&taskLinkInfo)
		if taskLinkInfo.AutoLinkBreakAt.IsZero() {
			err4 := db1.Where("task_id = ?", submitTaskNeedModId).Updates(&gorm_model.YounggeeLinkInfo{AutoLinkBreakAt: taskLinkInfo.RejectAt.Add(dd)}).Error
			if err4 != nil {
				return err4
			}
			fmt.Println("已添加链接违约自动处理时间")
			if taskLinkInfo.RejectAt.Add(dd).Sub(time.Now()) <= 0 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
					TaskID: submitTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[submitTaskNeedModId]), BreakType: 3, BreakAt: time.Now(), DefaultStatus: 1}).Error
				if err1 != nil {
					return err1
				}
				db3 := GetReadDB(context.Background())
				err2 := db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", submitTaskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{CurDefaultType: 5, LinkBreakRate: linkDefaultRate}).Error
				if err2 != nil {
					return err2
				}
				fmt.Println("创建时已违约则创建已提交链接的链接违约记录")
			}
		} else {
			if taskLinkInfo.AutoLinkBreakAt.Sub(time.Now()) <= 0 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
					TaskID: submitTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[submitTaskNeedModId]), BreakType: 3, BreakAt: time.Now(), DefaultStatus: 1}).Error
				if err1 != nil {
					return err1
				}
				db3 := GetReadDB(context.Background())
				err2 := db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", submitTaskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{CurDefaultType: 5, LinkBreakRate: linkDefaultRate}).Error
				if err2 != nil {
					return err2
				}
				fmt.Println("创建已提交链接的链接违约记录")
			}
		}
	}
	return nil
}

func GetAutoCaseCloseDefaultTask() error {
	db := GetReadDB(context.Background())
	var projectIds []int64
	err := db.Select("project_id").Model(gorm_model.ProjectInfo{}).Where("project_type = ?", 1).Find(&projectIds).Error
	if err != nil {
		return err
	}
	//fmt.Println("projectIds:", projectIds)
	// 任务id 对 项目id 的map
	taskIdToProjectIdMap := map[int]int64{}
	// 项目id 对 定时任务id 的map
	projectIdToAutoTaskIdMap := map[int64]int{}
	// 项目id 对 违约定时任务id 的map
	projectIdToAutoDefaultIdMap := map[int64]int{}
	var taskIds []int
	for _, projectId := range projectIds {
		db2 := GetReadDB(context.Background())
		autoIds := gorm_model.ProjectInfo{}
		db2.Select([]string{"auto_task_id", "auto_default_id"}).Model(&gorm_model.ProjectInfo{}).Where("project_id = ?", projectId).First(&autoIds)
		projectIdToAutoTaskIdMap[projectId] = int(autoIds.AutoTaskID)
		projectIdToAutoDefaultIdMap[projectId] = int(autoIds.AutoDefaultID)
		var taskInfos []int32
		db1 := GetReadDB(context.Background())
		db1.Select("task_id").Model(&gorm_model.YoungeeTaskInfo{}).Where("project_id = ? AND cur_default_type = ? ", projectId, 0).Find(&taskInfos)
		for _, taskInfo := range taskInfos {
			taskIdToProjectIdMap[int(taskInfo)] = projectId
			taskIds = append(taskIds, int(taskInfo))
		}
	}
	//fmt.Println("projectIdToAutoTaskIdMap:", projectIdToAutoTaskIdMap)
	//fmt.Println("projectIdToAutoDefaultIdMap:", projectIdToAutoDefaultIdMap)
	//fmt.Println("taskIdToProjectIdMap:", taskIdToProjectIdMap)
	//fmt.Println("taskIds:", taskIds)
	// 首次提交链接的任务记录id
	var taskNeedModIds []int
	// 已提交链接的任务记录id
	var submitTaskNeedModIds []int
	// taskId 对 稿费形式的 map
	taskIdToFeeFormMap := make(map[int]int)
	for _, taskId := range taskIds {
		var taskInfo gorm_model.YoungeeTaskInfo
		db3 := GetReadDB(context.Background())
		// 保存所有数据上传状态为 1  且任务状态为14 的任务记录的id
		db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskId).First(&taskInfo)
		if taskInfo.DataStatus == 1 && taskInfo.TaskStage == 14 {
			taskNeedModIds = append(taskNeedModIds, taskId)
		}
		// 保存所有数据上传状态为 3  且任务状态为14 的任务记录的id
		if taskInfo.DataStatus == 3 && taskInfo.TaskStage == 14 {
			submitTaskNeedModIds = append(submitTaskNeedModIds, taskId)
		}
		taskIdToFeeFormMap[taskId] = taskInfo.FeeForm
	}
	//fmt.Println("taskIdToFeeFormMap:", taskIdToFeeFormMap)
	//fmt.Println("taskNeedModIds:", taskNeedModIds)
	//fmt.Println("submitTaskNeedModIds:", submitTaskNeedModIds)
	for _, taskNeedModId := range taskNeedModIds {
		db2 := GetReadDB(context.Background())
		var CaseCloseDefault int32
		db2.Model(&gorm_model.InfoAutoTask{}).Select("case_close_default").Where("auto_task_id = ?", projectIdToAutoTaskIdMap[taskIdToProjectIdMap[taskNeedModId]]).First(&CaseCloseDefault)
		dd, _ := time.ParseDuration(conv.MustString(CaseCloseDefault, "") + "h")
		var dataDefaultRate int
		if taskIdToFeeFormMap[taskNeedModId] == 1 {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("data_replace_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[taskIdToProjectIdMap[taskNeedModId]]).Find(&dataDefaultRate)
		} else {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("data_other_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[taskIdToProjectIdMap[taskNeedModId]]).Find(&dataDefaultRate)
		}
		//fmt.Println("dataDefaultRate:", dataDefaultRate)
		db1 := GetReadDB(context.Background())
		var taskLinkInfo gorm_model.YounggeeLinkInfo
		db1.Model(gorm_model.YounggeeLinkInfo{}).Where("task_id = ? AND is_ok = ?", taskNeedModId, 1).Find(&taskLinkInfo)
		if taskLinkInfo.AutoDataBreakAt.IsZero() {
			db1.Where("task_id = ?", taskNeedModId).Updates(&gorm_model.YounggeeLinkInfo{AutoDataBreakAt: taskLinkInfo.AutoAgreeAt.Add(dd)})
			fmt.Println("已添加数据违约自动处理时间")
			if taskLinkInfo.AutoAgreeAt.Add(dd).Sub(time.Now()) <= 0 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
					TaskID: taskNeedModId, ProjectID: int(taskIdToProjectIdMap[taskNeedModId]), BreakType: 4, BreakAt: time.Now(), DefaultStatus: 1}).Error
				if err1 != nil {
					return err1
				}
				db3 := GetReadDB(context.Background())
				err2 := db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{CurDefaultType: 7, DataBreakRate: dataDefaultRate}).Error
				if err2 != nil {
					return err2
				}
				fmt.Println("创建时已违约则创建数据违约记录")
			}
		} else {
			if taskLinkInfo.AutoDataBreakAt.Sub(time.Now()) <= 0 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
					TaskID: taskNeedModId, ProjectID: int(taskIdToProjectIdMap[taskNeedModId]), BreakType: 4, BreakAt: time.Now(), DefaultStatus: 1}).Error
				if err1 != nil {
					return err1
				}
				db3 := GetReadDB(context.Background())
				err2 := db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", taskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{CurDefaultType: 7, DataBreakRate: dataDefaultRate}).Error
				if err2 != nil {
					return err2
				}
				fmt.Println("已创建数据违约记录")
			}
		}
	}
	// 根据最近一次拒绝时间判断当前是否违约
	for _, submitTaskNeedModId := range submitTaskNeedModIds {
		db2 := GetReadDB(context.Background())
		var LinkBreach int32
		db2.Model(&gorm_model.InfoAutoTask{}).Select("case_close_default").Where("auto_task_id = ?", projectIdToAutoTaskIdMap[taskIdToProjectIdMap[submitTaskNeedModId]]).First(&LinkBreach)
		dd, _ := time.ParseDuration(conv.MustString(LinkBreach, "") + "h")
		var dataDefaultRate int
		if taskIdToFeeFormMap[submitTaskNeedModId] == 1 {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("data_replace_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[taskIdToProjectIdMap[submitTaskNeedModId]]).Find(&dataDefaultRate)
		} else {
			db6 := GetReadDB(context.Background())
			db6.Model(gorm_model.InfoAutoDefaultHandle{}).Select("data_other_time_out").Where("auto_default_id = ?", projectIdToAutoDefaultIdMap[taskIdToProjectIdMap[submitTaskNeedModId]]).Find(&dataDefaultRate)
		}
		db1 := GetReadDB(context.Background())
		var taskDataInfo gorm_model.YounggeeDataInfo
		db1.Model(gorm_model.YounggeeDataInfo{}).Where("task_id = ?", submitTaskNeedModId).Order("reject_at desc").First(&taskDataInfo)
		if taskDataInfo.AutoDataBreakAt.IsZero() {
			err4 := db1.Where("task_id = ?", submitTaskNeedModId).Updates(&gorm_model.YounggeeDataInfo{AutoDataBreakAt: taskDataInfo.RejectAt.Add(dd)}).Error
			if err4 != nil {
				return err4
			}
			fmt.Println("已添加数据违约自动处理时间")
			if taskDataInfo.RejectAt.Add(dd).Sub(time.Now()) <= 0 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
					TaskID: submitTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[submitTaskNeedModId]), BreakType: 4, BreakAt: time.Now(), DefaultStatus: 1}).Error
				if err1 != nil {
					return err1
				}
				db3 := GetReadDB(context.Background())
				err2 := db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", submitTaskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{CurDefaultType: 7, DataBreakRate: dataDefaultRate}).Error
				if err2 != nil {
					return err2
				}
				fmt.Println("创建时已违约则创建已提交数据的数据违约记录")
			}
		} else {
			if taskDataInfo.AutoDataBreakAt.Sub(time.Now()) <= 0 {
				db4 := GetReadDB(context.Background())
				err1 := db4.Model(gorm_model.YoungeeContractInfo{}).Create(&gorm_model.YoungeeContractInfo{
					TaskID: submitTaskNeedModId, ProjectID: int(taskIdToProjectIdMap[submitTaskNeedModId]), BreakType: 4, BreakAt: time.Now(), DefaultStatus: 1}).Error
				if err1 != nil {
					return err1
				}
				db3 := GetReadDB(context.Background())
				err2 := db3.Model(gorm_model.YoungeeTaskInfo{}).Where("task_id = ?", submitTaskNeedModId).Updates(&gorm_model.YoungeeTaskInfo{
					CurDefaultType: 7, DataBreakRate: dataDefaultRate}).Error
				if err2 != nil {
					return err2
				}
				fmt.Println("创建已提交数据的数据违约记录")
			}
		}
	}
	return nil
}

func GetHours(ctx context.Context) (*http_model.Hours, error) {
	db := GetReadDB(ctx)
	infoAuto := gorm_model.InfoAutoTask{}
	err := db.Model(gorm_model.InfoAutoTask{}).Last(&infoAuto).Error
	if err != nil {
		return nil, err
	}
	Hours := http_model.Hours{}
	Hours.DraftDefaultInPic = infoAuto.DraftDefaultInPic
	Hours.DraftDefaultInMv = infoAuto.DraftDefaultInMv
	Hours.ScriptDefault = infoAuto.ScriptDefault
	Hours.Invalid = infoAuto.Invalid
	Hours.LinkBreach = infoAuto.LinkBreach
	Hours.CaseClose = infoAuto.CaseClose
	Hours.CaseCloseDefault = infoAuto.CaseCloseDefault
	Hours.ReviewInMv = infoAuto.ReviewInMv
	Hours.ReviewUnlimited = infoAuto.ReviewUnlimited
	Hours.PostReview = infoAuto.Postreview
	Hours.SignInVirtual = infoAuto.SignInVirtual
	Hours.SignInOffline = infoAuto.SignInOffline
	return &Hours, err
}

func GetPercents(ctx context.Context) (*http_model.Percents, error) {
	db := GetReadDB(ctx)
	percentsInfo := gorm_model.InfoAutoDefaultHandle{}
	err := db.Model(gorm_model.InfoAutoDefaultHandle{}).Last(&percentsInfo).Error
	if err != nil {
		return nil, err
	}
	Percents := http_model.Percents{}
	Percents.DataReplaceNotUpload = percentsInfo.DataReplaceNotUpload
	Percents.DataReplaceTimeOut = percentsInfo.DataReplaceTimeOut
	Percents.DataOtherTimeOut = percentsInfo.DataOtherTimeOut
	Percents.DataOtherNotUpload = percentsInfo.DataOtherNotUpload
	Percents.LinkReplaceTimeOut = percentsInfo.LinkReplaceTimeOut
	Percents.LinkReplaceNotUpload = percentsInfo.LinkReplaceNotUpload
	Percents.LinkOtherTimeOut = percentsInfo.LinkOtherTimeOut
	Percents.LinkOtherNotUpload = percentsInfo.LinkOtherNotUpload
	Percents.ScriptReplaceTimeOut = percentsInfo.ScriptReplaceTimeOut
	Percents.ScriptReplaceNotUpload = percentsInfo.ScriptReplaceNotUpload
	Percents.ScriptOtherNotUpload = percentsInfo.ScriptOtherNotUpload
	Percents.ScriptOtherTimeOut = percentsInfo.ScriptOtherTimeOut
	Percents.SketchReplaceTimeOut = percentsInfo.SketchReplaceTimeOut
	Percents.SketchOtherNotUpload = percentsInfo.SketchOtherNotUpload
	Percents.SketchOtherTimeOut = percentsInfo.SketchOtherTimeOut
	Percents.SketchReplaceNotUpload = percentsInfo.SketchReplaceNotUpload
	return &Percents, err
}