修改逻辑 ， 每日检查 任务异常

@@ -29,7 +29,7 @@ func CheckYesterdayTaskRecord() {
 			log.Logger.Info("获取每日任务反馈" + err.Error())
 			log.Logger.Info("获取每日任务反馈" + err.Error())
 		}
 		}
 		for _, val := range taskRecordList {
 		for _, val := range taskRecordList {
-			err = checkTaskRecordV2(val)
+			err = checkTaskRecordV3(val)
 			if err != nil {
 			if err != nil {
 				log.Logger.Info("检查每日任务反馈" + err.Error())
 				log.Logger.Info("检查每日任务反馈" + err.Error())
 			}
 			}

@@ -56,7 +56,7 @@ func TestCreatTaskAnamaly(t *testing.T) {
 	}
 	}
 
 
 	for _, val := range taskRacordList {
 	for _, val := range taskRacordList {
-		err = checkTaskRecordV2(val)
+		err = checkTaskRecordV3(val)
 		if err != nil {
 		if err != nil {
 			log.Logger.Info("检查每日任务反馈" + err.Error())
 			log.Logger.Info("检查每日任务反馈" + err.Error())
 		}
 		}

 package service
 package service
 
 
-import (
-	"fmt"
-	"time"
-
-	"github.com/linmadan/egglib-go/core/application"
-	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
-	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
-	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/utils/xtime"
-)
-
 // TODO 检查任务里程碑反馈， 记录异常情况
 // TODO 检查任务里程碑反馈， 记录异常情况
 
 
-func checkTaskRecordV2(param *domain.TaskRecord) error {
-	transactionContext, err := factory.CreateTransactionContext(nil)
-	if err != nil {
-		return err
-	}
-	if err := transactionContext.StartTransaction(); err != nil {
-		return err
-	}
-	defer func() {
-		_ = transactionContext.RollbackTransaction()
-	}()
-	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
-		"transactionContext": transactionContext,
-	})
-	_, taskDataList, err := taskRepo.Find(map[string]interface{}{"id": param.TaskId})
-	if err != nil {
-		return fmt.Errorf("获取任务数据失败：%s", err)
-	}
-	if len(taskDataList) == 0 {
-		return nil
-	}
-	taskData := taskDataList[0]
+// func checkTaskRecordV2(param *domain.TaskRecord) error {
+// 	transactionContext, err := factory.CreateTransactionContext(nil)
+// 	if err != nil {
+// 		return err
+// 	}
+// 	if err := transactionContext.StartTransaction(); err != nil {
+// 		return err
+// 	}
+// 	defer func() {
+// 		_ = transactionContext.RollbackTransaction()
+// 	}()
+// 	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
+// 		"transactionContext": transactionContext,
+// 	})
+// 	_, taskDataList, err := taskRepo.Find(map[string]interface{}{"id": param.TaskId})
+// 	if err != nil {
+// 		return fmt.Errorf("获取任务数据失败：%s", err)
+// 	}
+// 	if len(taskDataList) == 0 {
+// 		return nil
+// 	}
+// 	taskData := taskDataList[0]
 
 
-	//检查每日评估中任务的异常
-	// taskData.CheckAndRecordAnomaly(param)
+// 	//检查每日评估中任务的异常
 
 
-	// anomaly1 := &domain.TaskAnomaly{}
-	// ok := anomaly1.IsWarnFlag(taskData, param)
-	// if ok {
+// 	// anomaly1 := &domain.TaskAnomaly{}
+// 	// ok := anomaly1.IsWarnFlag(taskData, param)
+// 	// if ok {
 
 
-	// }
-	// 检查反馈异常
-	if param.IsRemarkAnomaly() {
-		taskData.Anomaly += 1
-		err = isAssessFlag(transactionContext, taskData, param)
-		if err != nil {
-			return err
-		}
-	} else {
-		taskData.Anomaly = 0
-		err = isNotAssessFlag(transactionContext, taskData, param)
-		if err != nil {
-			return err
-		}
-	}
-	// 检查里程碑异常
-	if param.IsTaskStageAnomaly() {
-		taskData.WarnFlag += 1
-		err := isWarnFlag(transactionContext, taskData, param)
-		if err != nil {
-			return err
-		}
-	} else {
-		taskData.WarnFlag = 0
-		err := isNotWarnFlag(transactionContext, taskData, param)
-		if err != nil {
-			return err
-		}
-	}
-	// 检查辅导异常
-	if param.IsAssistAnomaly() {
-		taskData.AssistFlag += 1
-		err = isAssistFlag(transactionContext, taskData, param)
-		if err != nil {
-			return err
-		}
-	} else {
-		taskData.AssistFlag = 0
-		err = isNotAssistFlag(transactionContext, taskData, param)
-		if err != nil {
-			return err
-		}
-	}
-	// 保存任务数据
-	err = taskRepo.Save(taskData)
-	if err != nil {
-		return fmt.Errorf("保存任务数据:%s", err)
-	}
+// 	// }
+// 	// 检查反馈异常
+// 	if param.IsRemarkAnomaly() {
+// 		taskData.Anomaly += 1
+// 		err = isAssessFlag(transactionContext, taskData, param)
+// 		if err != nil {
+// 			return err
+// 		}
+// 	} else {
+// 		taskData.Anomaly = 0
+// 		err = isNotAssessFlag(transactionContext, taskData, param)
+// 		if err != nil {
+// 			return err
+// 		}
+// 	}
+// 	// 检查里程碑异常
+// 	if param.IsTaskStageAnomaly() {
+// 		taskData.WarnFlag += 1
+// 		err := isWarnFlag(transactionContext, taskData, param)
+// 		if err != nil {
+// 			return err
+// 		}
+// 	} else {
+// 		taskData.WarnFlag = 0
+// 		err := isNotWarnFlag(transactionContext, taskData, param)
+// 		if err != nil {
+// 			return err
+// 		}
+// 	}
+// 	// 检查辅导异常
+// 	if param.IsAssistAnomaly() {
+// 		taskData.AssistFlag += 1
+// 		err = isAssistFlag(transactionContext, taskData, param)
+// 		if err != nil {
+// 			return err
+// 		}
+// 	} else {
+// 		taskData.AssistFlag = 0
+// 		err = isNotAssistFlag(transactionContext, taskData, param)
+// 		if err != nil {
+// 			return err
+// 		}
+// 	}
+// 	// 保存任务数据
+// 	err = taskRepo.Save(taskData)
+// 	if err != nil {
+// 		return fmt.Errorf("保存任务数据:%s", err)
+// 	}
 
 
-	if err := transactionContext.CommitTransaction(); err != nil {
-		return err
-	}
-	return nil
-}
+// 	if err := transactionContext.CommitTransaction(); err != nil {
+// 		return err
+// 	}
+// 	return nil
+// }
 
 
-// 取消里程碑异常
-func isNotWarnFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
-	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
-		"transactionContext": transactionContext,
-	})
-	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
-		"isLast":         1,
-		"category":       domain.AnomalyCategoryType1,
-		"limit":          1,
-		"taskId":         taskData.Id,
-		"taskStageCheck": fmt.Sprintf(`{"id":"%d"}`, taskRecord.TaskStageCheck.Id),
-	})
-	if err != nil {
-		return fmt.Errorf("查询里程碑异常的数据：%s", err)
-	}
-	if len(oldAnomaly) == 0 {
-		return nil
-	}
-	oldAnomaly[0].IsLast = 2
-	err = taskAnomalyRepo.Save(oldAnomaly[0])
-	if err != nil {
-		return fmt.Errorf("取消里程碑异常:%s", err)
-	}
-	return nil
-}
+// // 取消里程碑异常
+// func isNotWarnFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
+// 	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
+// 		"transactionContext": transactionContext,
+// 	})
+// 	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
+// 		"isLast":         1,
+// 		"category":       domain.AnomalyCategoryType1,
+// 		"limit":          1,
+// 		"taskId":         taskData.Id,
+// 		"taskStageCheck": fmt.Sprintf(`{"id":"%d"}`, taskRecord.TaskStageCheck.Id),
+// 	})
+// 	if err != nil {
+// 		return fmt.Errorf("查询里程碑异常的数据：%s", err)
+// 	}
+// 	if len(oldAnomaly) == 0 {
+// 		return nil
+// 	}
+// 	oldAnomaly[0].IsLast = 2
+// 	err = taskAnomalyRepo.Save(oldAnomaly[0])
+// 	if err != nil {
+// 		return fmt.Errorf("取消里程碑异常:%s", err)
+// 	}
+// 	return nil
+// }
 
 
-// 处理里程碑异常的情况, 日评中 里程碑未正常填写,包含 逾期完成，逾期未完成。
-// 记录异常
-func isWarnFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
+// // 处理里程碑异常的情况, 日评中 里程碑未正常填写,包含 逾期完成，逾期未完成。
+// // 记录异常
+// func isWarnFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
 
 
-	nowTime := time.Now()
-	if taskData.CurrentStage.Id == 0 && taskRecord.TaskStageCheck.RealCompletedAt > 0 {
-		// 逾期完成，且没有后续的任务
-		return isNotWarnFlag(transactionContext, taskData, taskRecord)
-	}
-	if taskData.CurrentStage.PlanCompletedAt > nowTime.Unix() && taskRecord.TaskStageCheck.RealCompletedAt > 0 {
-		//逾期完成，且后续任务为过期
-		return isNotWarnFlag(transactionContext, taskData, taskRecord)
-	}
+// 	nowTime := time.Now()
+// 	if taskData.CurrentStage.Id == 0 && taskRecord.TaskStageCheck.RealCompletedAt > 0 {
+// 		// 逾期完成，且没有后续的任务
+// 		return isNotWarnFlag(transactionContext, taskData, taskRecord)
+// 	}
+// 	if taskData.CurrentStage.PlanCompletedAt > nowTime.Unix() && taskRecord.TaskStageCheck.RealCompletedAt > 0 {
+// 		//逾期完成，且后续任务为过期
+// 		return isNotWarnFlag(transactionContext, taskData, taskRecord)
+// 	}
 
 
-	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
-		"transactionContext": transactionContext,
-	})
+// 	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
+// 		"transactionContext": transactionContext,
+// 	})
 
 
-	userRepo := factory.CreateUserRepository(map[string]interface{}{
-		"transactionContext": transactionContext,
-	})
+// 	userRepo := factory.CreateUserRepository(map[string]interface{}{
+// 		"transactionContext": transactionContext,
+// 	})
 
 
-	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
-		"isLast":         1,
-		"category":       domain.AnomalyCategoryType1,
-		"limit":          1,
-		"taskId":         taskData.Id,
-		"taskStageCheck": fmt.Sprintf(`{"id":"%d"}`, taskRecord.TaskStageCheck.Id),
-	})
-	if err != nil {
-		return fmt.Errorf("查询里程碑异常的数据：%s", err)
-	}
+// 	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
+// 		"isLast":         1,
+// 		"category":       domain.AnomalyCategoryType1,
+// 		"limit":          1,
+// 		"taskId":         taskData.Id,
+// 		"taskStageCheck": fmt.Sprintf(`{"id":"%d"}`, taskRecord.TaskStageCheck.Id),
+// 	})
+// 	if err != nil {
+// 		return fmt.Errorf("查询里程碑异常的数据：%s", err)
+// 	}
 
 
-	anomalyDataTmp := domain.TaskAnomaly{
-		Id:             0,
-		CreatedAt:      time.Now(),
-		UpdatedAt:      time.Now(),
-		CompanyId:      taskData.CompanyId,
-		TaskId:         taskData.Id,
-		TaskRecordId:   taskRecord.Id,
-		Category:       domain.AnomalyCategoryType1,
-		CurrentStage:   taskData.CurrentStage,
-		LastStage:      taskData.LastStage,
-		TaskStageCheck: taskRecord.TaskStageCheck,
-		AssessFlag:     0,
-		WarnFlag:       int(taskData.WarnFlag),
-		AssistFlag:     0,
-		IsLast:         1,
-		RecordBegin:    taskRecord.CreatedAt.Unix(),
-		NoticeWho:      []map[string]string{},
-		Marks: map[string]string{
-			"a": "去更新", "b": "去反馈", "c": "找上级", "d": "去辅导",
-		},
-	}
-	if len(oldAnomaly) > 0 {
-		anomalyDataTmp.WarnFlag = oldAnomaly[0].WarnFlag + 1
-		anomalyDataTmp.RecordBegin = oldAnomaly[0].RecordBegin
-		oldAnomaly[0].IsLast = 2
-		err = taskAnomalyRepo.Save(oldAnomaly[0])
-		if err != nil {
-			return fmt.Errorf("更新里程碑异常记录：%s", err)
-		}
-	}
-	_ = anomalyDataTmp.AnomalyDesc()
-	// 异常就通知自己和上级
-	//获取任务Leader的数据
-	_, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
-	if err != nil {
-		return fmt.Errorf("获取任务Leader:%s", err)
-	}
-	var userParentId int64
-	if len(useList) > 0 {
-		anomalyDataTmp.SetNoticeWho(useList[0])
-		userParentId = useList[0].ParentId
-	}
+// 	anomalyDataTmp := domain.TaskAnomaly{
+// 		Id:             0,
+// 		CreatedAt:      time.Now(),
+// 		UpdatedAt:      time.Now(),
+// 		CompanyId:      taskData.CompanyId,
+// 		TaskId:         taskData.Id,
+// 		TaskRecordId:   taskRecord.Id,
+// 		Category:       domain.AnomalyCategoryType1,
+// 		CurrentStage:   taskData.CurrentStage,
+// 		LastStage:      taskData.LastStage,
+// 		TaskStageCheck: taskRecord.TaskStageCheck,
+// 		AssessFlag:     0,
+// 		WarnFlag:       int(taskData.WarnFlag),
+// 		AssistFlag:     0,
+// 		IsLast:         1,
+// 		RecordBegin:    taskRecord.CreatedAt.Unix(),
+// 		NoticeWho:      []map[string]string{},
+// 		Marks: map[string]string{
+// 			"a": "去更新", "b": "去反馈", "c": "找上级", "d": "去辅导",
+// 		},
+// 	}
+// 	if len(oldAnomaly) > 0 {
+// 		anomalyDataTmp.WarnFlag = oldAnomaly[0].WarnFlag + 1
+// 		anomalyDataTmp.RecordBegin = oldAnomaly[0].RecordBegin
+// 		oldAnomaly[0].IsLast = 2
+// 		err = taskAnomalyRepo.Save(oldAnomaly[0])
+// 		if err != nil {
+// 			return fmt.Errorf("更新里程碑异常记录：%s", err)
+// 		}
+// 	}
+// 	_ = anomalyDataTmp.AnomalyDesc()
+// 	// 异常就通知自己和上级
+// 	//获取任务Leader的数据
+// 	_, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
+// 	if err != nil {
+// 		return fmt.Errorf("获取任务Leader:%s", err)
+// 	}
+// 	var userParentId int64
+// 	if len(useList) > 0 {
+// 		anomalyDataTmp.SetNoticeWho(useList[0])
+// 		userParentId = useList[0].ParentId
+// 	}
 
 
-	if userParentId > 0 {
-		// 获取上级用户的数据
-		_, useList2, err := userRepo.Find(map[string]interface{}{"id": userParentId, "limit": 1})
-		if err != nil {
-			return fmt.Errorf("获取任务Leader的上级:%s", err)
-		}
-		if len(useList2) > 0 {
-			anomalyDataTmp.SetNoticeWho(useList2[0])
-		}
-	}
-	err = taskAnomalyRepo.Save(&anomalyDataTmp)
-	if err != nil {
-		return fmt.Errorf("保存里程碑异常记录：%s", err)
-	}
-	return nil
-}
+// 	if userParentId > 0 {
+// 		// 获取上级用户的数据
+// 		_, useList2, err := userRepo.Find(map[string]interface{}{"id": userParentId, "limit": 1})
+// 		if err != nil {
+// 			return fmt.Errorf("获取任务Leader的上级:%s", err)
+// 		}
+// 		if len(useList2) > 0 {
+// 			anomalyDataTmp.SetNoticeWho(useList2[0])
+// 		}
+// 	}
+// 	err = taskAnomalyRepo.Save(&anomalyDataTmp)
+// 	if err != nil {
+// 		return fmt.Errorf("保存里程碑异常记录：%s", err)
+// 	}
+// 	return nil
+// }
 
 
-// 取消辅导异常的情况
-func isNotAssistFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
-	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
-		"transactionContext": transactionContext,
-	})
+// // 取消辅导异常的情况
+// func isNotAssistFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
+// 	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
+// 		"transactionContext": transactionContext,
+// 	})
 
 
-	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
-		"isLast":   1,
-		"category": domain.AnomalyCategoryType3,
-		"limit":    1,
-		"taskId":   taskData.Id,
-	})
-	if err != nil {
-		return fmt.Errorf("查询辅导异常的数据：%s", err)
-	}
-	if len(oldAnomaly) == 0 {
-		return nil
-	}
-	oldAnomaly[0].IsLast = 2
-	err = taskAnomalyRepo.Save(oldAnomaly[0])
-	if err != nil {
-		return fmt.Errorf("取消辅导异常:%s", err)
-	}
-	return nil
-}
+// 	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
+// 		"isLast":   1,
+// 		"category": domain.AnomalyCategoryType3,
+// 		"limit":    1,
+// 		"taskId":   taskData.Id,
+// 	})
+// 	if err != nil {
+// 		return fmt.Errorf("查询辅导异常的数据：%s", err)
+// 	}
+// 	if len(oldAnomaly) == 0 {
+// 		return nil
+// 	}
+// 	oldAnomaly[0].IsLast = 2
+// 	err = taskAnomalyRepo.Save(oldAnomaly[0])
+// 	if err != nil {
+// 		return fmt.Errorf("取消辅导异常:%s", err)
+// 	}
+// 	return nil
+// }
 
 
-// 处理辅导异常的情况
-func isAssistFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
-	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
-		"transactionContext": transactionContext,
-	})
+// // 处理辅导异常的情况
+// func isAssistFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
+// 	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
+// 		"transactionContext": transactionContext,
+// 	})
 
 
-	userRepo := factory.CreateUserRepository(map[string]interface{}{
-		"transactionContext": transactionContext,
-	})
+// 	userRepo := factory.CreateUserRepository(map[string]interface{}{
+// 		"transactionContext": transactionContext,
+// 	})
 
 
-	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
-		"isLast":   1,
-		"category": domain.AnomalyCategoryType3,
-		"limit":    1,
-		"taskId":   taskData.Id,
-	})
-	if err != nil {
-		return fmt.Errorf("查询辅导异常的数据：%s", err)
-	}
-	// 辅导异常通知该条任务负责人的上级；辅导异常超过N天，通知任务负责人的上上级
-	anomalyDataTmp := domain.TaskAnomaly{
-		Id:             0,
-		CreatedAt:      time.Now(),
-		UpdatedAt:      time.Now(),
-		CompanyId:      taskData.CompanyId,
-		TaskRecordId:   taskRecord.Id,
-		TaskId:         taskData.Id,
-		Category:       domain.AnomalyCategoryType3,
-		CurrentStage:   taskData.CurrentStage,
-		LastStage:      taskData.LastStage,
-		TaskStageCheck: taskRecord.TaskStageCheck,
-		AssessFlag:     0,
-		WarnFlag:       0,
-		AssistFlag:     taskData.AssistFlag,
-		IsLast:         1,
-		RecordBegin:    taskRecord.CreatedAt.Unix(),
-		NoticeWho:      []map[string]string{},
-		Marks: map[string]string{
-			"a": "去更新", "b": "去反馈", "c": "找上级", "d": "去辅导",
-		},
-	}
+// 	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
+// 		"isLast":   1,
+// 		"category": domain.AnomalyCategoryType3,
+// 		"limit":    1,
+// 		"taskId":   taskData.Id,
+// 	})
+// 	if err != nil {
+// 		return fmt.Errorf("查询辅导异常的数据：%s", err)
+// 	}
+// 	// 辅导异常通知该条任务负责人的上级；辅导异常超过N天，通知任务负责人的上上级
+// 	anomalyDataTmp := domain.TaskAnomaly{
+// 		Id:             0,
+// 		CreatedAt:      time.Now(),
+// 		UpdatedAt:      time.Now(),
+// 		CompanyId:      taskData.CompanyId,
+// 		TaskRecordId:   taskRecord.Id,
+// 		TaskId:         taskData.Id,
+// 		Category:       domain.AnomalyCategoryType3,
+// 		CurrentStage:   taskData.CurrentStage,
+// 		LastStage:      taskData.LastStage,
+// 		TaskStageCheck: taskRecord.TaskStageCheck,
+// 		AssessFlag:     0,
+// 		WarnFlag:       0,
+// 		AssistFlag:     taskData.AssistFlag,
+// 		IsLast:         1,
+// 		RecordBegin:    taskRecord.CreatedAt.Unix(),
+// 		NoticeWho:      []map[string]string{},
+// 		Marks: map[string]string{
+// 			"a": "去更新", "b": "去反馈", "c": "找上级", "d": "去辅导",
+// 		},
+// 	}
 
 
-	if len(oldAnomaly) > 0 {
-		anomalyDataTmp.RecordBegin = oldAnomaly[0].RecordBegin
-		oldAnomaly[0].IsLast = 2
-		err = taskAnomalyRepo.Save(oldAnomaly[0])
-		if err != nil {
-			return fmt.Errorf("更新里程碑异常记录：%s", err)
-		}
-	}
-	_ = anomalyDataTmp.AnomalyDesc()
-	//获取任务Leader的数据
-	_, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
-	if err != nil {
-		return fmt.Errorf("获取任务Leader:%s", err)
-	}
-	var userParentId int64
-	if len(useList) > 0 {
-		userParentId = useList[0].ParentId
-	}
-	if userParentId > 0 {
-		//通知任务负责人的上级
-		_, useList2, err := userRepo.Find(map[string]interface{}{"id": userParentId, "limit": 1})
-		if err != nil {
-			return fmt.Errorf("获取任务Leader:%s", err)
-		}
-		var userParentId2 int64
-		if len(useList2) > 0 {
-			anomalyDataTmp.SetNoticeWho(useList2[0])
-			userParentId2 = useList2[0].ParentId
-		}
-		// 辅导异常超过N天,通知任务负责人的上上级
-		if taskData.AssistFlag >= taskData.AssistFlagMax && userParentId2 > 0 {
-			_, useList3, err := userRepo.Find(map[string]interface{}{"id": userParentId, "limit": 1})
-			if err != nil {
-				return fmt.Errorf("获取任务Leader:%s", err)
-			}
-			if len(useList3) > 0 {
-				anomalyDataTmp.SetNoticeWho(useList3[0])
-			}
-		}
-	}
+// 	if len(oldAnomaly) > 0 {
+// 		anomalyDataTmp.RecordBegin = oldAnomaly[0].RecordBegin
+// 		oldAnomaly[0].IsLast = 2
+// 		err = taskAnomalyRepo.Save(oldAnomaly[0])
+// 		if err != nil {
+// 			return fmt.Errorf("更新里程碑异常记录：%s", err)
+// 		}
+// 	}
+// 	_ = anomalyDataTmp.AnomalyDesc()
+// 	//获取任务Leader的数据
+// 	_, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
+// 	if err != nil {
+// 		return fmt.Errorf("获取任务Leader:%s", err)
+// 	}
+// 	var userParentId int64
+// 	if len(useList) > 0 {
+// 		userParentId = useList[0].ParentId
+// 	}
+// 	if userParentId > 0 {
+// 		//通知任务负责人的上级
+// 		_, useList2, err := userRepo.Find(map[string]interface{}{"id": userParentId, "limit": 1})
+// 		if err != nil {
+// 			return fmt.Errorf("获取任务Leader:%s", err)
+// 		}
+// 		var userParentId2 int64
+// 		if len(useList2) > 0 {
+// 			anomalyDataTmp.SetNoticeWho(useList2[0])
+// 			userParentId2 = useList2[0].ParentId
+// 		}
+// 		// 辅导异常超过N天,通知任务负责人的上上级
+// 		if taskData.AssistFlag >= taskData.AssistFlagMax && userParentId2 > 0 {
+// 			_, useList3, err := userRepo.Find(map[string]interface{}{"id": userParentId, "limit": 1})
+// 			if err != nil {
+// 				return fmt.Errorf("获取任务Leader:%s", err)
+// 			}
+// 			if len(useList3) > 0 {
+// 				anomalyDataTmp.SetNoticeWho(useList3[0])
+// 			}
+// 		}
+// 	}
 
 
-	err = taskAnomalyRepo.Save(&anomalyDataTmp)
-	if err != nil {
-		return fmt.Errorf("保存里程碑异常记录：%s", err)
-	}
-	return nil
+// 	err = taskAnomalyRepo.Save(&anomalyDataTmp)
+// 	if err != nil {
+// 		return fmt.Errorf("保存里程碑异常记录：%s", err)
+// 	}
+// 	return nil
 
 
-}
+// }
 
 
-// 取消反馈异常的情况
-func isNotAssessFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
-	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
-		"transactionContext": transactionContext,
-	})
+// // 取消反馈异常的情况
+// func isNotAssessFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
+// 	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
+// 		"transactionContext": transactionContext,
+// 	})
 
 
-	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
-		"isLast":   1,
-		"category": domain.AnomalyCategoryType2,
-		"limit":    1,
-		"taskId":   taskData.Id,
-	})
-	if err != nil {
-		return fmt.Errorf("查询辅导异常的数据：%s", err)
-	}
-	if len(oldAnomaly) == 0 {
-		return nil
-	}
-	oldAnomaly[0].IsLast = 2
-	err = taskAnomalyRepo.Save(oldAnomaly[0])
-	if err != nil {
-		return fmt.Errorf("取消辅导异常:%s", err)
-	}
-	return nil
-}
+// 	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
+// 		"isLast":   1,
+// 		"category": domain.AnomalyCategoryType2,
+// 		"limit":    1,
+// 		"taskId":   taskData.Id,
+// 	})
+// 	if err != nil {
+// 		return fmt.Errorf("查询辅导异常的数据：%s", err)
+// 	}
+// 	if len(oldAnomaly) == 0 {
+// 		return nil
+// 	}
+// 	oldAnomaly[0].IsLast = 2
+// 	err = taskAnomalyRepo.Save(oldAnomaly[0])
+// 	if err != nil {
+// 		return fmt.Errorf("取消辅导异常:%s", err)
+// 	}
+// 	return nil
+// }
 
 
-// 处理反馈异常的情况
-func isAssessFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
-	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
-		"transactionContext": transactionContext,
-	})
-	userRepo := factory.CreateUserRepository(map[string]interface{}{
-		"transactionContext": transactionContext,
-	})
-	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
-		"isLast":   1,
-		"category": domain.AnomalyCategoryType2,
-		"limit":    1,
-		"taskId":   taskData.Id,
-	})
-	if err != nil {
-		return fmt.Errorf("查询反馈异常的数据：%s", err)
-	}
-	//
-	anomalyDataTmp := domain.TaskAnomaly{
-		Id:             0,
-		CreatedAt:      time.Now(),
-		UpdatedAt:      time.Now(),
-		CompanyId:      taskData.CompanyId,
-		TaskId:         taskData.Id,
-		TaskRecordId:   taskRecord.Id,
-		Category:       domain.AnomalyCategoryType2,
-		CurrentStage:   taskData.CurrentStage,
-		LastStage:      taskData.LastStage,
-		TaskStageCheck: taskRecord.TaskStageCheck,
-		AssessFlag:     taskData.Anomaly,
-		WarnFlag:       0,
-		AssistFlag:     0,
-		IsLast:         1,
-		RecordBegin:    taskRecord.CreatedAt.Unix(),
-		NoticeWho:      []map[string]string{},
-		Marks: map[string]string{
-			"a": "去更新", "b": "去反馈", "c": "找上级", "d": "去辅导",
-		},
-	}
-	if len(oldAnomaly) > 0 {
-		anomalyDataTmp.RecordBegin = oldAnomaly[0].RecordBegin
-		oldAnomaly[0].IsLast = 2
-		err = taskAnomalyRepo.Save(oldAnomaly[0])
-		if err != nil {
-			return fmt.Errorf("更新里程碑异常记录：%s", err)
-		}
-	}
-	_ = anomalyDataTmp.AnomalyDesc()
-	// 2天未反馈通知被评估人自己；3天通知上级
-	// 获取任务Leader的数据
-	_, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
-	if err != nil {
-		return fmt.Errorf("获取任务Leader:%s", err)
-	}
-	var userParentId int64
-	if len(useList) > 0 {
-		anomalyDataTmp.SetNoticeWho(useList[0])
-		userParentId = useList[0].ParentId
-	}
-	anomalyDay := xtime.SubDayAbs(time.Now(), time.Unix(anomalyDataTmp.RecordBegin, 0))
-	if anomalyDay >= 3 && userParentId > 0 {
-		_, useList2, err := userRepo.Find(map[string]interface{}{"id": userParentId, "limit": 1})
-		if err != nil {
-			return fmt.Errorf("获取任务Leader:%s", err)
-		}
-		if len(useList2) > 0 {
-			anomalyDataTmp.SetNoticeWho(useList2[0])
-		}
-	}
-	err = taskAnomalyRepo.Save(&anomalyDataTmp)
-	if err != nil {
-		return fmt.Errorf("保存里程碑异常记录：%s", err)
-	}
-	return nil
+// // 处理反馈异常的情况
+// func isAssessFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
+// 	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
+// 		"transactionContext": transactionContext,
+// 	})
+// 	userRepo := factory.CreateUserRepository(map[string]interface{}{
+// 		"transactionContext": transactionContext,
+// 	})
+// 	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
+// 		"isLast":   1,
+// 		"category": domain.AnomalyCategoryType2,
+// 		"limit":    1,
+// 		"taskId":   taskData.Id,
+// 	})
+// 	if err != nil {
+// 		return fmt.Errorf("查询反馈异常的数据：%s", err)
+// 	}
+// 	//
+// 	anomalyDataTmp := domain.TaskAnomaly{
+// 		Id:             0,
+// 		CreatedAt:      time.Now(),
+// 		UpdatedAt:      time.Now(),
+// 		CompanyId:      taskData.CompanyId,
+// 		TaskId:         taskData.Id,
+// 		TaskRecordId:   taskRecord.Id,
+// 		Category:       domain.AnomalyCategoryType2,
+// 		CurrentStage:   taskData.CurrentStage,
+// 		LastStage:      taskData.LastStage,
+// 		TaskStageCheck: taskRecord.TaskStageCheck,
+// 		AssessFlag:     taskData.Anomaly,
+// 		WarnFlag:       0,
+// 		AssistFlag:     0,
+// 		IsLast:         1,
+// 		RecordBegin:    taskRecord.CreatedAt.Unix(),
+// 		NoticeWho:      []map[string]string{},
+// 		Marks: map[string]string{
+// 			"a": "去更新", "b": "去反馈", "c": "找上级", "d": "去辅导",
+// 		},
+// 	}
+// 	if len(oldAnomaly) > 0 {
+// 		anomalyDataTmp.RecordBegin = oldAnomaly[0].RecordBegin
+// 		oldAnomaly[0].IsLast = 2
+// 		err = taskAnomalyRepo.Save(oldAnomaly[0])
+// 		if err != nil {
+// 			return fmt.Errorf("更新里程碑异常记录：%s", err)
+// 		}
+// 	}
+// 	_ = anomalyDataTmp.AnomalyDesc()
+// 	// 2天未反馈通知被评估人自己；3天通知上级
+// 	// 获取任务Leader的数据
+// 	_, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
+// 	if err != nil {
+// 		return fmt.Errorf("获取任务Leader:%s", err)
+// 	}
+// 	var userParentId int64
+// 	if len(useList) > 0 {
+// 		anomalyDataTmp.SetNoticeWho(useList[0])
+// 		userParentId = useList[0].ParentId
+// 	}
+// 	anomalyDay := xtime.SubDayAbs(time.Now(), time.Unix(anomalyDataTmp.RecordBegin, 0))
+// 	if anomalyDay >= 3 && userParentId > 0 {
+// 		_, useList2, err := userRepo.Find(map[string]interface{}{"id": userParentId, "limit": 1})
+// 		if err != nil {
+// 			return fmt.Errorf("获取任务Leader:%s", err)
+// 		}
+// 		if len(useList2) > 0 {
+// 			anomalyDataTmp.SetNoticeWho(useList2[0])
+// 		}
+// 	}
+// 	err = taskAnomalyRepo.Save(&anomalyDataTmp)
+// 	if err != nil {
+// 		return fmt.Errorf("保存里程碑异常记录：%s", err)
+// 	}
+// 	return nil
 
 
-}
+// }

+package service
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/linmadan/egglib-go/core/application"
+	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
+	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
+	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/utils/xtime"
+)
+
+func checkTaskRecordV3(param *domain.TaskRecord) error {
+	transactionContext, err := factory.CreateTransactionContext(nil)
+	if err != nil {
+		return err
+	}
+	if err := transactionContext.StartTransaction(); err != nil {
+		return err
+	}
+	defer func() {
+		_ = transactionContext.RollbackTransaction()
+	}()
+	taskRepo := factory.CreateTaskRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	})
+	_, taskDataList, err := taskRepo.Find(map[string]interface{}{"id": param.TaskId})
+	if err != nil {
+		return fmt.Errorf("获取任务数据失败：%s", err)
+	}
+	if len(taskDataList) == 0 {
+		return nil
+	}
+	taskData := taskDataList[0]
+	//检查每日评估中任务的异常
+	taskData.CheckAndRecordAnomaly(param)
+	err = taskRepo.Save(taskData)
+	if err != nil {
+		return fmt.Errorf("保存任务数据:%s", err)
+	}
+	//异常中心记录 里程碑异常
+	anomaly1 := &domain.TaskAnomaly{}
+	ok := anomaly1.IsWarnFlag(taskData, param)
+	if ok {
+		err = anomalyIsWarnFlag(transactionContext, anomaly1, taskData)
+		if err != nil {
+			return err
+		}
+	} else {
+		err = anomalyIsNotWarnFlag(transactionContext, taskData, param)
+		if err != nil {
+			return err
+		}
+	}
+	// 异常中心 记录反馈异常
+	anomaly2 := &domain.TaskAnomaly{}
+	ok = anomaly2.IsAssessFlag(taskData, param)
+	if ok {
+		err = anomalyisAssessFlag(transactionContext, anomaly1, taskData)
+		if err != nil {
+			return err
+		}
+	} else {
+		err = anomalyIsNotAssessFlag(transactionContext, taskData)
+		if err != nil {
+			return err
+		}
+	}
+	// 异常中心记录辅导异常
+	anomaly3 := &domain.TaskAnomaly{}
+	ok = anomaly2.IsAssistFlag(taskData, param)
+	if ok {
+		anomalyIsAssistFlag(transactionContext, anomaly3, taskData)
+		if err != nil {
+			return err
+		}
+	} else {
+		err = anomalyIsNotAssistFlag(transactionContext, taskData)
+		if err != nil {
+			return err
+		}
+	}
+	if err := transactionContext.CommitTransaction(); err != nil {
+		return err
+	}
+	return nil
+}
+
+// 取消里程碑异常
+func anomalyIsNotWarnFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
+	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	})
+	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
+		"isLast":   1,
+		"category": domain.AnomalyCategoryType1,
+		"limit":    1,
+		"taskId":   taskData.Id,
+		// "taskStageCheck": fmt.Sprintf(`{"id":"%d"}`, taskRecord.TaskStageCheck.Id),
+	})
+	if err != nil {
+		return fmt.Errorf("查询里程碑异常的数据：%s", err)
+	}
+	if len(oldAnomaly) == 0 {
+		return nil
+	}
+	oldAnomaly[0].IsLast = 2
+	err = taskAnomalyRepo.Save(oldAnomaly[0])
+	if err != nil {
+		return fmt.Errorf("取消里程碑异常:%s", err)
+	}
+	return nil
+}
+
+// 记录里程碑异常
+func anomalyIsWarnFlag(transactionContext application.TransactionContext, taskAnomalyData *domain.TaskAnomaly, taskData *domain.Task) error {
+	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	})
+	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
+		"isLast":         1,
+		"category":       domain.AnomalyCategoryType1,
+		"limit":          1,
+		"taskId":         taskAnomalyData.TaskId,
+		"taskStageCheck": fmt.Sprintf(`{"id":"%d"}`, taskAnomalyData.TaskStageCheck.Id),
+	})
+	if err != nil {
+		return fmt.Errorf("查询里程碑异常的数据：%s", err)
+	}
+
+	userRepo := factory.CreateUserRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	})
+	if len(oldAnomaly) > 0 {
+		taskAnomalyData.WarnFlag = oldAnomaly[0].WarnFlag + 1
+		taskAnomalyData.RecordBegin = oldAnomaly[0].RecordBegin
+		oldAnomaly[0].IsLast = 2
+		err = taskAnomalyRepo.Save(oldAnomaly[0])
+		if err != nil {
+			return fmt.Errorf("更新里程碑异常记录：%s", err)
+		}
+	}
+	_ = taskAnomalyData.AnomalyDesc()
+	// 异常就通知自己和上级
+	//获取任务Leader的数据
+	_, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
+	if err != nil {
+		return fmt.Errorf("获取任务Leader:%s", err)
+	}
+	var userParentId int64
+	if len(useList) > 0 {
+		taskAnomalyData.SetNoticeWho(useList[0])
+		userParentId = useList[0].ParentId
+	}
+	if userParentId > 0 {
+		// 获取上级用户的数据
+		_, useList2, err := userRepo.Find(map[string]interface{}{"id": userParentId, "limit": 1})
+		if err != nil {
+			return fmt.Errorf("获取任务Leader的上级:%s", err)
+		}
+		if len(useList2) > 0 {
+			taskAnomalyData.SetNoticeWho(useList2[0])
+		}
+	}
+	err = taskAnomalyRepo.Save(taskAnomalyData)
+	if err != nil {
+		return fmt.Errorf("保存里程碑异常记录：%s", err)
+	}
+	return nil
+}
+
+// 取消反馈异常
+func anomalyIsNotAssessFlag(transactionContext application.TransactionContext, taskData *domain.Task) error {
+	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	})
+	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
+		"isLast":   1,
+		"category": domain.AnomalyCategoryType2,
+		"limit":    1,
+		"taskId":   taskData.Id,
+	})
+	if err != nil {
+		return fmt.Errorf("查询反馈异常的数据：%s", err)
+	}
+	if len(oldAnomaly) == 0 {
+		return nil
+	}
+	oldAnomaly[0].IsLast = 2
+	err = taskAnomalyRepo.Save(oldAnomaly[0])
+	if err != nil {
+		return fmt.Errorf("取消辅导异常:%s", err)
+	}
+	return nil
+}
+
+// 处理反馈异常的情况
+func anomalyisAssessFlag(transactionContext application.TransactionContext, taskAnomalyData *domain.TaskAnomaly, taskData *domain.Task) error {
+	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	})
+	userRepo := factory.CreateUserRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	})
+	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
+		"isLast":   1,
+		"category": domain.AnomalyCategoryType2,
+		"limit":    1,
+		"taskId":   taskAnomalyData.TaskId,
+	})
+	if err != nil {
+		return fmt.Errorf("查询反馈异常的数据：%s", err)
+	}
+	//
+	if len(oldAnomaly) > 0 {
+		taskAnomalyData.RecordBegin = oldAnomaly[0].RecordBegin
+		oldAnomaly[0].IsLast = 2
+		err = taskAnomalyRepo.Save(oldAnomaly[0])
+		if err != nil {
+			return fmt.Errorf("更新反馈异常记录：%s", err)
+		}
+	}
+	_ = taskAnomalyData.AnomalyDesc()
+	// 2天未反馈通知被评估人自己；3天通知上级
+	// 获取任务Leader的数据
+	_, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
+	if err != nil {
+		return fmt.Errorf("获取任务Leader:%s", err)
+	}
+	var userParentId int64
+	if len(useList) > 0 {
+		taskAnomalyData.SetNoticeWho(useList[0])
+		userParentId = useList[0].ParentId
+	}
+	anomalyDay := xtime.SubDayAbs(time.Now(), time.Unix(taskAnomalyData.RecordBegin, 0))
+
+	if anomalyDay >= 3 && userParentId > 0 {
+		_, useList2, err := userRepo.Find(map[string]interface{}{"id": userParentId, "limit": 1})
+		if err != nil {
+			return fmt.Errorf("获取任务Leader:%s", err)
+		}
+		if len(useList2) > 0 {
+			taskAnomalyData.SetNoticeWho(useList2[0])
+		}
+	}
+	err = taskAnomalyRepo.Save(taskAnomalyData)
+	if err != nil {
+		return fmt.Errorf("保存里程碑异常记录：%s", err)
+	}
+	return nil
+
+}
+
+// 取消辅导异常
+func anomalyIsNotAssistFlag(transactionContext application.TransactionContext, taskData *domain.Task) error {
+	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	})
+
+	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
+		"isLast":   1,
+		"category": domain.AnomalyCategoryType3,
+		"limit":    1,
+		"taskId":   taskData.Id,
+	})
+	if err != nil {
+		return fmt.Errorf("查询辅导异常的数据：%s", err)
+	}
+	if len(oldAnomaly) == 0 {
+		return nil
+	}
+	oldAnomaly[0].IsLast = 2
+	err = taskAnomalyRepo.Save(oldAnomaly[0])
+	if err != nil {
+		return fmt.Errorf("取消辅导异常:%s", err)
+	}
+	return nil
+}
+
+// 处理辅导异常的情况
+func anomalyIsAssistFlag(transactionContext application.TransactionContext, taskAnomalyData *domain.TaskAnomaly, taskData *domain.Task) error {
+	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	})
+
+	userRepo := factory.CreateUserRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	})
+
+	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
+		"isLast":   1,
+		"category": domain.AnomalyCategoryType3,
+		"limit":    1,
+		"taskId":   taskAnomalyData.TaskId,
+	})
+	if err != nil {
+		return fmt.Errorf("查询辅导异常的数据：%s", err)
+	}
+	// 辅导异常通知该条任务负责人的上级,通知任务负责人的上上级
+	if len(oldAnomaly) > 0 {
+		taskAnomalyData.RecordBegin = oldAnomaly[0].RecordBegin
+		oldAnomaly[0].IsLast = 2
+		err = taskAnomalyRepo.Save(oldAnomaly[0])
+		if err != nil {
+			return fmt.Errorf("更新里程碑异常记录：%s", err)
+		}
+	}
+	_ = taskAnomalyData.AnomalyDesc()
+	//获取任务Leader的数据
+	_, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
+	if err != nil {
+		return fmt.Errorf("获取任务Leader:%s", err)
+	}
+	var userParentId int64
+	if len(useList) > 0 {
+		userParentId = useList[0].ParentId
+	}
+	if userParentId > 0 {
+		//通知任务负责人的上级
+		_, useList2, err := userRepo.Find(map[string]interface{}{"id": userParentId, "limit": 1})
+		if err != nil {
+			return fmt.Errorf("获取任务Leader:%s", err)
+		}
+		var userParentId2 int64
+		if len(useList2) > 0 {
+			taskAnomalyData.SetNoticeWho(useList2[0])
+			userParentId2 = useList2[0].ParentId
+		}
+		// 辅导异常超过N天,通知任务负责人的上上级
+		if taskData.AssistFlag >= taskData.AssistFlagMax && userParentId2 > 0 {
+			_, useList3, err := userRepo.Find(map[string]interface{}{"id": userParentId, "limit": 1})
+			if err != nil {
+				return fmt.Errorf("获取任务Leader:%s", err)
+			}
+			if len(useList3) > 0 {
+				taskAnomalyData.SetNoticeWho(useList3[0])
+			}
+		}
+	}
+	err = taskAnomalyRepo.Save(taskAnomalyData)
+	if err != nil {
+		return fmt.Errorf("保存里程碑异常记录：%s", err)
+	}
+	return nil
+
+}

 package domain
 package domain
 
 
 import (
 import (
-	"strings"
 	"time"
 	"time"
 )
 )
 
 
@@ -55,44 +54,44 @@ type TaskRecordRepository interface {
 }
 }
 
 
 // 是否是辅导异常
 // 是否是辅导异常
-func (r *TaskRecord) IsAssistAnomaly() bool {
-	//TODO 判断是否辅导异常
+// func (r *TaskRecord) IsAssistAnomaly() bool {
+// 	//TODO 判断是否辅导异常
 
 
-	r.AssistContent = strings.TrimSpace(r.AssistContent)
-	if r.AssistLevel == AssistLevel1 || r.AssistContent == "无" || len(r.AssistContent) == 0 {
-		return true
-	}
+// 	r.AssistContent = strings.TrimSpace(r.AssistContent)
+// 	if r.AssistLevel == AssistLevel1 || r.AssistContent == "无" || len(r.AssistContent) == 0 {
+// 		return true
+// 	}
 
 
-	return false
-}
+// 	return false
+// }
 
 
 // 是否是里程碑异常
 // 是否是里程碑异常
-func (r *TaskRecord) IsTaskStageAnomaly() bool {
-	if r.TaskStageCheck.Id == 0 {
-		return false
-	}
-	realCompletedAt := r.TaskStageCheck.RealCompletedAt
-	if realCompletedAt == 0 {
-		//假设现在完成
-		realCompletedAt = time.Now().Unix()
-	}
-	if r.TaskStageCheck.PlanCompletedAt < realCompletedAt {
-		//逾期完成，或者预期未完成
-		return true
-	}
+// func (r *TaskRecord) IsTaskStageAnomaly() bool {
+// 	if r.TaskStageCheck.Id == 0 {
+// 		return false
+// 	}
+// 	realCompletedAt := r.TaskStageCheck.RealCompletedAt
+// 	if realCompletedAt == 0 {
+// 		//假设现在完成
+// 		realCompletedAt = time.Now().Unix()
+// 	}
+// 	if r.TaskStageCheck.PlanCompletedAt < realCompletedAt {
+// 		//逾期完成，或者预期未完成
+// 		return true
+// 	}
 
 
-	return false
-}
+// 	return false
+// }
 
 
 // 是否是反馈异常
 // 是否是反馈异常
-func (r *TaskRecord) IsRemarkAnomaly() bool {
-	all := ""
-	for _, val := range r.RemarkContent {
-		txt := strings.TrimSpace(val.RemarkText)
-		all += txt
-	}
-	if len(all) == 0 || all == "无" {
-		return true
-	}
-	return false
-}
+// func (r *TaskRecord) IsRemarkAnomaly() bool {
+// 	all := ""
+// 	for _, val := range r.RemarkContent {
+// 		txt := strings.TrimSpace(val.RemarkText)
+// 		all += txt
+// 	}
+// 	if len(all) == 0 || all == "无" {
+// 		return true
+// 	}
+// 	return false
+// }