保存

@@ -581,6 +581,7 @@ func (srv *MessagePersonalService) TodayMessageTaskStageModifyV2(param *command.
 	return resp, nil
 }
 
+// 里程碑异常的消息弹窗通知
 func (srv *MessagePersonalService) TodayMessageTaskAnomaly(param *command.GetUserMessageCommand) (map[string]interface{}, error) {
 
 	transactionContext, err := factory.CreateTransactionContext(nil)

@@ -34,6 +34,15 @@ func checkTaskRecordV2(param *domain.TaskRecord) error {
 		return nil
 	}
 	taskData := taskDataList[0]
+
+	//检查每日评估中任务的异常
+	// taskData.CheckAndRecordAnomaly(param)
+
+	// anomaly1 := &domain.TaskAnomaly{}
+	// ok := anomaly1.IsWarnFlag(taskData, param)
+	// if ok {
+
+	// }
 	// 检查反馈异常
 	if param.IsRemarkAnomaly() {
 		taskData.Anomaly += 1
@@ -50,13 +59,13 @@ func checkTaskRecordV2(param *domain.TaskRecord) error {
 	}
 	// 检查里程碑异常
 	if param.IsTaskStageAnomaly() {
-		taskData.WarnFlag = domain.TaskWarn
+		taskData.WarnFlag += 1
 		err := isWarnFlag(transactionContext, taskData, param)
 		if err != nil {
 			return err
 		}
 	} else {
-		taskData.WarnFlag = domain.TaskWarnNull
+		taskData.WarnFlag = 0
 		err := isNotWarnFlag(transactionContext, taskData, param)
 		if err != nil {
 			return err

@@ -861,18 +861,18 @@ func (srv TaskService) ReplyTaskStage(transactionContext application.Transaction
 		}
 
 		//改为定时检查每日任务反馈，并计算反馈异常数
-		for _, val2 := range stageList {
-			if val2.Id != val.TaskStageCheck.Id {
-				continue
-			}
-			val2.RealCompletedAt = val.TaskStageCheck.RealCompletedAt
-			if val2.PlanCompletedAt < val2.RealCompletedAt {
-				taskData.WarnFlag = domain.TaskWarn
-			} else {
-				taskData.WarnFlag = domain.TaskWarnNull
-			}
-			break
-		}
+		// for _, val2 := range stageList {
+		// 	if val2.Id != val.TaskStageCheck.Id {
+		// 		continue
+		// 	}
+		// 	val2.RealCompletedAt = val.TaskStageCheck.RealCompletedAt
+		// 	if val2.PlanCompletedAt < val2.RealCompletedAt {
+		// 		taskData.WarnFlag = 1
+		// 	} else {
+		// 		taskData.WarnFlag = 0
+		// 	}
+		// 	break
+		// }
 		err = taskStageRepo.Save(stageList)
 		if err != nil {
 			return application.ThrowError(application.INTERNAL_SERVER_ERROR, "保存任务里程碑数据"+err.Error())

@@ -3,6 +3,7 @@ package domain
 import (
 	"errors"
 	"sort"
+	"strings"
 	"time"
 )
 
@@ -58,30 +59,30 @@ func (t TaskSortBy) Named() string {
 
 // 任务
 type Task struct {
-	Id            int          `json:"id"`
-	CreatedAt     time.Time    `json:"createdAt"`
-	UpdatedAt     time.Time    `json:"updatedAt"`
-	DeletedAt     *time.Time   `json:"deletedAt"`
-	CompanyId     int          `json:"companyId,string"`
-	Name          string       `json:"name"`          // 任务名称
-	Alias         string       `json:"alias"`         // 任务别名
-	Leader        TaskLeader   `json:"leader"`        // 任务负责人
-	Status        TaskState    `json:"status"`        // 任务的状态
-	Level         int          `json:"level"`         // 优先级 (优先级字段表示的意义变更,不再需要这个字段,仅数据保留)
-	LevelName     string       `json:"levelName"`     // 字段表示的意义变更; 原来 (“优先级名称“)=> 现在 (“任务类型“)
-	SortBy        TaskSortBy   `json:"sortBy"`        // 优先级排序;值越小优先级越高
-	EndTime       int64        `json:"endTime"`       // 任务截止的时间戳，单位:秒；等于0时表示未设置时间
-	UseEndTime    int          `json:"useEndTime"`    // 是否应用任务截止的时间;默认值0:不应用,1:应用
-	RelatedUser   []int        `json:"relatedUser"`   // 相关的员工id
-	RunAt         int64        `json:"runAt"`         // 启动的时间戳,单位:秒
-	StopAt        int64        `json:"stopAt"`        // 停止的时间戳,单位:秒
-	Anomaly       int          `json:"anomaly"`       // 异常反馈的次数
-	WarnFlag      TaskWarnFlag `json:"warnFlag"`      // 里程碑异常标记
-	AssistFlag    int          `json:"assistFlag"`    // 辅导异常标记
-	AssistFlagMax int          `json:"assistFlagMax"` // 辅导异常标记最大值
-	CurrentStage  TaskStage    `json:"currentStage"`  // 当前执行的里程碑
-	LastStage     TaskStage    `json:"lastStage"`     // 上一个完成的里程碑
-	CreatedBy     int          `json:"createdBy"`     // 任务的创建方式 0: 根据模板中的任务创建，1：页面主动直接创建
+	Id            int        `json:"id"`
+	CreatedAt     time.Time  `json:"createdAt"`
+	UpdatedAt     time.Time  `json:"updatedAt"`
+	DeletedAt     *time.Time `json:"deletedAt"`
+	CompanyId     int        `json:"companyId,string"`
+	Name          string     `json:"name"`          // 任务名称
+	Alias         string     `json:"alias"`         // 任务别名
+	Leader        TaskLeader `json:"leader"`        // 任务负责人
+	Status        TaskState  `json:"status"`        // 任务的状态
+	Level         int        `json:"level"`         // 优先级 (优先级字段表示的意义变更,不再需要这个字段,仅数据保留)
+	LevelName     string     `json:"levelName"`     // 字段表示的意义变更; 原来 (“优先级名称“)=> 现在 (“任务类型“)
+	SortBy        TaskSortBy `json:"sortBy"`        // 优先级排序;值越小优先级越高
+	EndTime       int64      `json:"endTime"`       // 任务截止的时间戳，单位:秒；等于0时表示未设置时间
+	UseEndTime    int        `json:"useEndTime"`    // 是否应用任务截止的时间;默认值0:不应用,1:应用
+	RelatedUser   []int      `json:"relatedUser"`   // 相关的员工id
+	RunAt         int64      `json:"runAt"`         // 启动的时间戳,单位:秒
+	StopAt        int64      `json:"stopAt"`        // 停止的时间戳,单位:秒
+	Anomaly       int        `json:"anomaly"`       // 异常反馈的次数
+	WarnFlag      int        `json:"warnFlag"`      // 里程碑异常标记
+	AssistFlag    int        `json:"assistFlag"`    // 辅导异常标记
+	AssistFlagMax int        `json:"assistFlagMax"` // 辅导异常标记最大值
+	CurrentStage  TaskStage  `json:"currentStage"`  // 当前执行的里程碑
+	LastStage     TaskStage  `json:"lastStage"`     // 上一个完成的里程碑
+	CreatedBy     int        `json:"createdBy"`     // 任务的创建方式 0: 根据模板中的任务创建，1：页面主动直接创建
 }
 
 type TaskLeader struct {
@@ -160,7 +161,7 @@ func (t *Task) DescriptTaskStatus() string {
 	if t.Status == TaskStop {
 		statusNamed = "已停止"
 	}
-	if t.WarnFlag == TaskWarn {
+	if t.WarnFlag > 0 {
 		statusNamed = "里程碑异常"
 	}
 	if t.Anomaly > 0 {
@@ -176,6 +177,51 @@ func (t *Task) Copy() Task {
 	return t2
 }
 
+// 检查每日任务是否异常，并记录异常情况
+func (t *Task) CheckAndRecordAnomaly(taskRecordData *TaskRecord) {
+	nowTime := time.Now().Unix()
+	// 检查是否是里程碑异常
+	{
+		if taskRecordData.TaskStageCheck.Id > 0 {
+			if taskRecordData.TaskStageCheck.RealCompletedAt == 0 && taskRecordData.TaskStageCheck.PlanCompletedAt < nowTime {
+				// 超期未完成
+				t.WarnFlag += 1
+			} else if taskRecordData.TaskStageCheck.RealCompletedAt > 0 {
+				// 里程碑完成, 重置计数
+				t.WarnFlag = 0
+			}
+		}
+	}
+	// 检查反馈异常
+	{
+		t.Anomaly += 1
+		for _, val := range taskRecordData.RemarkContent {
+			txt := strings.TrimSpace(val.RemarkText)
+			if len(txt) == 0 || txt == "无" {
+				continue
+			}
+			//反馈正常，重置计数
+			t.Anomaly = 0
+			break
+		}
+	}
+	// 检查辅导异常
+	{
+		taskRecordData.AssistContent = strings.TrimSpace(taskRecordData.AssistContent)
+		if t.Anomaly == 0 && t.WarnFlag == 0 {
+			//里程碑正常，反馈正常， 设定为已辅导
+			t.AssistFlag = 0
+		} else {
+			//里程碑和反馈 其中一个不正常，记录一次辅导异常
+			t.AssistFlag += 1
+		}
+		if taskRecordData.AssistLevel != AssistLevel1 && !(taskRecordData.AssistContent == "无" || len(taskRecordData.AssistContent) == 0) {
+			//只要正常填写的辅导都设定为已辅导
+			t.AssistFlag = 0
+		}
+	}
+}
+
 type TaskRepository interface {
 	Save(param *Task) error
 	Remove(id int) error

@@ -115,16 +115,95 @@ func (t *TaskAnomaly) AnomalyDesc() (str string) {
 
 // 检查是否是反馈异常
 func (t *TaskAnomaly) IsAssessFlag(taskData *Task, taskRecordData *TaskRecord) bool {
-
-	return false
+	if taskData.Anomaly <= 0 {
+		return false
+	}
+	*t = TaskAnomaly{
+		Id:             0,
+		CreatedAt:      time.Now(),
+		UpdatedAt:      time.Now(),
+		CompanyId:      taskData.CompanyId,
+		TaskId:         taskData.Id,
+		TaskRecordId:   taskRecordData.Id,
+		Category:       AnomalyCategoryType2,
+		CurrentStage:   taskData.CurrentStage,
+		LastStage:      taskData.LastStage,
+		TaskStageCheck: taskRecordData.TaskStageCheck,
+		AssessFlag:     1,
+		WarnFlag:       0,
+		AssistFlag:     0,
+		IsLast:         1,
+		RecordBegin:    xtime.DayZeroTime(taskRecordData.CreatedAt).Unix(),
+		NoticeWho:      []map[string]string{},
+		Marks: map[string]string{
+			"a": "去更新", "b": "去反馈", "c": "找上级", "d": "去辅导",
+		},
+		Remark: "",
+	}
+	return true
 }
 
 // 检查是否是里程碑异常
 func (t *TaskAnomaly) IsWarnFlag(taskData *Task, taskRecordData *TaskRecord) bool {
-	return false
+	if taskData.CurrentStage.Id == 0 {
+		// 没有新的里程碑
+		return false
+	}
+	if taskData.CurrentStage.PlanCompletedAt > time.Now().Unix() {
+		//新的里程碑未过期， 不计入异常情况
+		return false
+	}
+	*t = TaskAnomaly{
+		Id:             0,
+		CreatedAt:      time.Now(),
+		UpdatedAt:      time.Now(),
+		CompanyId:      taskData.CompanyId,
+		TaskId:         taskData.Id,
+		TaskRecordId:   taskRecordData.Id,
+		Category:       AnomalyCategoryType1,
+		CurrentStage:   taskData.CurrentStage,
+		LastStage:      taskData.LastStage,
+		TaskStageCheck: taskRecordData.TaskStageCheck,
+		AssessFlag:     0,
+		WarnFlag:       1,
+		AssistFlag:     0,
+		IsLast:         1,
+		RecordBegin:    xtime.DayZeroTime(taskRecordData.CreatedAt).Unix(),
+		NoticeWho:      []map[string]string{},
+		Marks: map[string]string{
+			"a": "去更新", "b": "去反馈", "c": "找上级", "d": "去辅导",
+		},
+		Remark: "",
+	}
+	return true
 }
 
-// 检查是否是辅导异常
+// 检查是否是辅导异常，
 func (t *TaskAnomaly) IsAssistFlag(taskData *Task, taskRecordData *TaskRecord) bool {
-	return false
+	if taskData.AssistFlag < taskData.AssistFlagMax {
+		return false
+	}
+	*t = TaskAnomaly{
+		Id:             0,
+		CreatedAt:      time.Now(),
+		UpdatedAt:      time.Now(),
+		CompanyId:      taskData.CompanyId,
+		TaskId:         taskData.Id,
+		TaskRecordId:   taskRecordData.Id,
+		Category:       AnomalyCategoryType3,
+		CurrentStage:   taskData.CurrentStage,
+		LastStage:      taskData.LastStage,
+		TaskStageCheck: taskRecordData.TaskStageCheck,
+		AssessFlag:     taskData.Anomaly,
+		WarnFlag:       taskData.WarnFlag,
+		AssistFlag:     taskData.AssistFlag,
+		IsLast:         1,
+		RecordBegin:    xtime.DayZeroTime(taskRecordData.CreatedAt).Unix(),
+		NoticeWho:      []map[string]string{},
+		Marks: map[string]string{
+			"a": "去更新", "b": "去反馈", "c": "找上级", "d": "去辅导",
+		},
+		Remark: "",
+	}
+	return true
 }

@@ -44,7 +44,7 @@ func (repo *TaskRepository) TransformToDomain(d *models.Task) *domain.Task {
 		RunAt:         d.RunAt,
 		StopAt:        d.StopAt,
 		Anomaly:       d.Anomaly,
-		WarnFlag:      domain.TaskWarnFlag(d.WarnFlag),
+		WarnFlag:      d.WarnFlag,
 		AssistFlag:    d.AssistFlag,
 		AssistFlagMax: d.AssistFlagMax,
 		CurrentStage:  d.CurrentStage,