Merge branch 'dev-tangxvhui' into test

@@ -5,24 +5,26 @@ import (
 )
 )
 
 
 type TaskItem struct {
 type TaskItem struct {
-	Id             int       `json:"id,string"`
-	Name           string    `json:"name"`           // 任务名称
-	Alias          string    `json:"alias"`          // 任务别名
-	Leader         string    `json:"leader"`         // 任务负责人
-	Status         int       `json:"status"`         // 任务的状态
-	StatusDescript string    `json:"statusDescript"` //任务的整体状态描述
-	SortBy         int       `json:"level"`          // 优先级,值越小优先级越高
-	LevelName      string    `json:"levelName"`      // 任务分类名称
-	StageA         TaskStage `json:"stageA"`         // 里程碑1
-	StageB         TaskStage `json:"stageB"`         // 里程碑2
-	StageC         TaskStage `json:"stageC"`         // 里程碑3
-	StageD         TaskStage `json:"stageD"`         // 里程碑4
-	StageE         TaskStage `json:"stageE"`         // 里程碑5
-	LastStage      TaskStage `json:"lastStage"`      //
-	CurrentStage   TaskStage `json:"currentStage"`   //
-	UpdatedAt      string    `json:"updatedAt"`      //
-	Anomaly        int       `json:"anomaly"`        //异常反馈情况
-	WarnFlag       int       `json:"warnFlag"`       //里程碑完成时间异常标记  0:正常  1标记为异常
+	Id             int               `json:"id,string"`
+	Name           string            `json:"name"`           // 任务名称
+	Alias          string            `json:"alias"`          // 任务别名
+	Leader         string            `json:"leader"`         // 任务负责人
+	Status         int               `json:"status"`         // 任务的状态
+	StatusDescript string            `json:"statusDescript"` // 任务的整体状态描述
+	SortBy         int               `json:"level"`          // 优先级,值越小优先级越高
+	LevelName      string            `json:"levelName"`      // 任务分类名称
+	StageA         TaskStage         `json:"stageA"`         // 里程碑1
+	StageB         TaskStage         `json:"stageB"`         // 里程碑2
+	StageC         TaskStage         `json:"stageC"`         // 里程碑3
+	StageD         TaskStage         `json:"stageD"`         // 里程碑4
+	StageE         TaskStage         `json:"stageE"`         // 里程碑5
+	LastStage      TaskStage         `json:"lastStage"`      //
+	CurrentStage   TaskStage         `json:"currentStage"`   //
+	UpdatedAt      string            `json:"updatedAt"`      //
+	Anomaly        int               `json:"anomaly"`        // 异常反馈情况
+	WarnFlag       int               `json:"warnFlag"`       // 里程碑完成时间异常标记  0:正常  1标记为异常
+	AnomalyDesc    []string          `json:"anomalyDesc"`    // 异常状态
+	Marks          map[string]string `json:"marks"`          // 标记
 }
 }
 
 
 func (t *TaskItem) GenStatusDescript() {
 func (t *TaskItem) GenStatusDescript() {

+package adapter
+
+// 人员选择列表
+type UserItem struct {
+	Id    int64  `json:"id,string"`
+	Name  string `json:"name"`
+	Level int    `json:"level"`
+}

+package command
+
+type MarkTaskAnomalyCommand struct {
+	Id        int    `json:"id,string"`
+	CompanyId int    `json:"-"`
+	MarkType  string `json:"markType"`
+}

+package command
+
+type UserSelectCommand struct {
+	UserId    int `json:"-"`
+	CompanyId int `json:"-"`
+	SubLevel  int `json:"subLevel"`
+}

@@ -2,6 +2,9 @@ package service
 
 
 import (
 import (
 	"testing"
 	"testing"
+
+	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
+	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/log"
 )
 )
 
 
 func TestCheckYesterdayTaskRecord(t *testing.T) {
 func TestCheckYesterdayTaskRecord(t *testing.T) {
@@ -21,3 +24,41 @@ func TestCheckYesterdayTaskRecord(t *testing.T) {
 		}
 		}
 	}
 	}
 }
 }
+
+func TestCreatTaskAnamaly(t *testing.T) {
+	transactionContext, err := factory.CreateTransactionContext(nil)
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	if err := transactionContext.StartTransaction(); err != nil {
+		t.Error(err)
+		return
+	}
+	defer func() {
+		_ = transactionContext.RollbackTransaction()
+	}()
+
+	taskRecordRepo := factory.CreateTaskRecordRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	})
+	_, taskRacordList, err := taskRecordRepo.Find(map[string]interface{}{
+		"ids": []int{1669736612939960320},
+	})
+	if err != nil {
+		t.Error(err)
+		return
+	}
+	if err := transactionContext.CommitTransaction(); err != nil {
+		t.Error(err)
+		return
+	}
+
+	for _, val := range taskRacordList {
+		err = checkTaskRecordV2(val)
+		if err != nil {
+			log.Logger.Info("检查每日任务反馈" + err.Error())
+		}
+	}
+
+}

@@ -95,7 +95,7 @@ func isNotWarnFlag(transactionContext application.TransactionContext, taskData *
 	})
 	})
 	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
 	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
 		"isLast":         1,
 		"isLast":         1,
-		"category":       2,
+		"category":       domain.AnomalyCategoryType1,
 		"limit":          1,
 		"limit":          1,
 		"taskId":         taskData.Id,
 		"taskId":         taskData.Id,
 		"taskStageCheck": fmt.Sprintf(`{"id":"%d"}`, taskRecord.TaskStageCheck.Id),
 		"taskStageCheck": fmt.Sprintf(`{"id":"%d"}`, taskRecord.TaskStageCheck.Id),
@@ -108,7 +108,10 @@ func isNotWarnFlag(transactionContext application.TransactionContext, taskData *
 	}
 	}
 	oldAnomaly[0].IsLast = 2
 	oldAnomaly[0].IsLast = 2
 	err = taskAnomalyRepo.Save(oldAnomaly[0])
 	err = taskAnomalyRepo.Save(oldAnomaly[0])
-	return fmt.Errorf("取消里程碑异常:%s", err)
+	if err != nil {
+		return fmt.Errorf("取消里程碑异常:%s", err)
+	}
+	return nil
 }
 }
 
 
 // 处理里程碑异常的情况
 // 处理里程碑异常的情况
@@ -123,7 +126,7 @@ func isWarnFlag(transactionContext application.TransactionContext, taskData *dom
 
 
 	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
 	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
 		"isLast":         1,
 		"isLast":         1,
-		"category":       2,
+		"category":       domain.AnomalyCategoryType1,
 		"limit":          1,
 		"limit":          1,
 		"taskId":         taskData.Id,
 		"taskId":         taskData.Id,
 		"taskStageCheck": fmt.Sprintf(`{"id":"%d"}`, taskRecord.TaskStageCheck.Id),
 		"taskStageCheck": fmt.Sprintf(`{"id":"%d"}`, taskRecord.TaskStageCheck.Id),
@@ -133,13 +136,13 @@ func isWarnFlag(transactionContext application.TransactionContext, taskData *dom
 	}
 	}
 
 
 	anomalyDataTmp := domain.TaskAnomaly{
 	anomalyDataTmp := domain.TaskAnomaly{
-		Id:             taskData.Id,
+		Id:             0,
 		CreatedAt:      time.Now(),
 		CreatedAt:      time.Now(),
 		UpdatedAt:      time.Now(),
 		UpdatedAt:      time.Now(),
 		CompanyId:      taskData.CompanyId,
 		CompanyId:      taskData.CompanyId,
 		TaskId:         taskData.Id,
 		TaskId:         taskData.Id,
 		TaskRecordId:   taskRecord.Id,
 		TaskRecordId:   taskRecord.Id,
-		Category:       1,
+		Category:       domain.AnomalyCategoryType1,
 		CurrentStage:   taskData.CurrentStage,
 		CurrentStage:   taskData.CurrentStage,
 		LastStage:      taskData.LastStage,
 		LastStage:      taskData.LastStage,
 		TaskStageCheck: taskRecord.TaskStageCheck,
 		TaskStageCheck: taskRecord.TaskStageCheck,
@@ -150,7 +153,7 @@ func isWarnFlag(transactionContext application.TransactionContext, taskData *dom
 		RecordBegin:    taskRecord.CreatedAt.Unix(),
 		RecordBegin:    taskRecord.CreatedAt.Unix(),
 		NoticeWho:      []map[string]string{},
 		NoticeWho:      []map[string]string{},
 		Marks: map[string]string{
 		Marks: map[string]string{
-			"a": "", "b": "", "c": "", "d": "",
+			"a": "去更新", "b": "去反馈", "c": "找上级", "d": "去辅导",
 		},
 		},
 	}
 	}
 	if len(oldAnomaly) > 0 {
 	if len(oldAnomaly) > 0 {
@@ -162,6 +165,7 @@ func isWarnFlag(transactionContext application.TransactionContext, taskData *dom
 			return fmt.Errorf("更新里程碑异常记录：%s", err)
 			return fmt.Errorf("更新里程碑异常记录：%s", err)
 		}
 		}
 	}
 	}
+	_ = anomalyDataTmp.AnomalyDesc()
 	// 异常就通知自己和上级
 	// 异常就通知自己和上级
 	//获取任务Leader的数据
 	//获取任务Leader的数据
 	_, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
 	_, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
@@ -199,7 +203,7 @@ func isNotAssistFlag(transactionContext application.TransactionContext, taskData
 
 
 	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
 	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
 		"isLast":   1,
 		"isLast":   1,
-		"category": 3,
+		"category": domain.AnomalyCategoryType3,
 		"limit":    1,
 		"limit":    1,
 		"taskId":   taskData.Id,
 		"taskId":   taskData.Id,
 	})
 	})
@@ -211,7 +215,10 @@ func isNotAssistFlag(transactionContext application.TransactionContext, taskData
 	}
 	}
 	oldAnomaly[0].IsLast = 2
 	oldAnomaly[0].IsLast = 2
 	err = taskAnomalyRepo.Save(oldAnomaly[0])
 	err = taskAnomalyRepo.Save(oldAnomaly[0])
-	return fmt.Errorf("取消辅导异常:%s", err)
+	if err != nil {
+		return fmt.Errorf("取消辅导异常:%s", err)
+	}
+	return nil
 }
 }
 
 
 // 处理辅导异常的情况
 // 处理辅导异常的情况
@@ -226,7 +233,7 @@ func isAssistFlag(transactionContext application.TransactionContext, taskData *d
 
 
 	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
 	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
 		"isLast":   1,
 		"isLast":   1,
-		"category": 3,
+		"category": domain.AnomalyCategoryType3,
 		"limit":    1,
 		"limit":    1,
 		"taskId":   taskData.Id,
 		"taskId":   taskData.Id,
 	})
 	})
@@ -235,12 +242,12 @@ func isAssistFlag(transactionContext application.TransactionContext, taskData *d
 	}
 	}
 	// 辅导异常通知该条任务负责人的上级；辅导异常超过N天，通知任务负责人的上上级
 	// 辅导异常通知该条任务负责人的上级；辅导异常超过N天，通知任务负责人的上上级
 	anomalyDataTmp := domain.TaskAnomaly{
 	anomalyDataTmp := domain.TaskAnomaly{
-		Id:             taskData.Id,
+		Id:             0,
 		CreatedAt:      time.Now(),
 		CreatedAt:      time.Now(),
 		UpdatedAt:      time.Now(),
 		UpdatedAt:      time.Now(),
 		CompanyId:      taskData.CompanyId,
 		CompanyId:      taskData.CompanyId,
 		TaskId:         taskData.Id,
 		TaskId:         taskData.Id,
-		Category:       3,
+		Category:       domain.AnomalyCategoryType3,
 		CurrentStage:   taskData.CurrentStage,
 		CurrentStage:   taskData.CurrentStage,
 		LastStage:      taskData.LastStage,
 		LastStage:      taskData.LastStage,
 		TaskStageCheck: taskRecord.TaskStageCheck,
 		TaskStageCheck: taskRecord.TaskStageCheck,
@@ -251,7 +258,7 @@ func isAssistFlag(transactionContext application.TransactionContext, taskData *d
 		RecordBegin:    taskRecord.CreatedAt.Unix(),
 		RecordBegin:    taskRecord.CreatedAt.Unix(),
 		NoticeWho:      []map[string]string{},
 		NoticeWho:      []map[string]string{},
 		Marks: map[string]string{
 		Marks: map[string]string{
-			"a": "", "b": "", "c": "", "d": "",
+			"a": "去更新", "b": "去反馈", "c": "找上级", "d": "去辅导",
 		},
 		},
 	}
 	}
 
 
@@ -263,6 +270,7 @@ func isAssistFlag(transactionContext application.TransactionContext, taskData *d
 			return fmt.Errorf("更新里程碑异常记录：%s", err)
 			return fmt.Errorf("更新里程碑异常记录：%s", err)
 		}
 		}
 	}
 	}
+	_ = anomalyDataTmp.AnomalyDesc()
 	//获取任务Leader的数据
 	//获取任务Leader的数据
 	_, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
 	_, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
 	if err != nil {
 	if err != nil {
@@ -311,7 +319,7 @@ func isNotAssessFlag(transactionContext application.TransactionContext, taskData
 
 
 	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
 	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
 		"isLast":   1,
 		"isLast":   1,
-		"category": 3,
+		"category": domain.AnomalyCategoryType2,
 		"limit":    1,
 		"limit":    1,
 		"taskId":   taskData.Id,
 		"taskId":   taskData.Id,
 	})
 	})
@@ -323,8 +331,10 @@ func isNotAssessFlag(transactionContext application.TransactionContext, taskData
 	}
 	}
 	oldAnomaly[0].IsLast = 2
 	oldAnomaly[0].IsLast = 2
 	err = taskAnomalyRepo.Save(oldAnomaly[0])
 	err = taskAnomalyRepo.Save(oldAnomaly[0])
-	return fmt.Errorf("取消辅导异常:%s", err)
-
+	if err != nil {
+		return fmt.Errorf("取消辅导异常:%s", err)
+	}
+	return nil
 }
 }
 
 
 // 处理反馈异常的情况
 // 处理反馈异常的情况
@@ -337,7 +347,7 @@ func isAssessFlag(transactionContext application.TransactionContext, taskData *d
 	})
 	})
 	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
 	_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
 		"isLast":   1,
 		"isLast":   1,
-		"category": 2,
+		"category": domain.AnomalyCategoryType2,
 		"limit":    1,
 		"limit":    1,
 		"taskId":   taskData.Id,
 		"taskId":   taskData.Id,
 	})
 	})
@@ -346,12 +356,12 @@ func isAssessFlag(transactionContext application.TransactionContext, taskData *d
 	}
 	}
 	//
 	//
 	anomalyDataTmp := domain.TaskAnomaly{
 	anomalyDataTmp := domain.TaskAnomaly{
-		Id:             taskData.Id,
+		Id:             0,
 		CreatedAt:      time.Now(),
 		CreatedAt:      time.Now(),
 		UpdatedAt:      time.Now(),
 		UpdatedAt:      time.Now(),
 		CompanyId:      taskData.CompanyId,
 		CompanyId:      taskData.CompanyId,
 		TaskId:         taskData.Id,
 		TaskId:         taskData.Id,
-		Category:       3,
+		Category:       domain.AnomalyCategoryType2,
 		CurrentStage:   taskData.CurrentStage,
 		CurrentStage:   taskData.CurrentStage,
 		LastStage:      taskData.LastStage,
 		LastStage:      taskData.LastStage,
 		TaskStageCheck: taskRecord.TaskStageCheck,
 		TaskStageCheck: taskRecord.TaskStageCheck,
@@ -362,7 +372,7 @@ func isAssessFlag(transactionContext application.TransactionContext, taskData *d
 		RecordBegin:    taskRecord.CreatedAt.Unix(),
 		RecordBegin:    taskRecord.CreatedAt.Unix(),
 		NoticeWho:      []map[string]string{},
 		NoticeWho:      []map[string]string{},
 		Marks: map[string]string{
 		Marks: map[string]string{
-			"a": "", "b": "", "c": "", "d": "",
+			"a": "去更新", "b": "去反馈", "c": "找上级", "d": "去辅导",
 		},
 		},
 	}
 	}
 	if len(oldAnomaly) > 0 {
 	if len(oldAnomaly) > 0 {
@@ -373,6 +383,7 @@ func isAssessFlag(transactionContext application.TransactionContext, taskData *d
 			return fmt.Errorf("更新里程碑异常记录：%s", err)
 			return fmt.Errorf("更新里程碑异常记录：%s", err)
 		}
 		}
 	}
 	}
+	_ = anomalyDataTmp.AnomalyDesc()
 	// 2天未反馈通知被评估人自己；3天通知上级
 	// 2天未反馈通知被评估人自己；3天通知上级
 	// 获取任务Leader的数据
 	// 获取任务Leader的数据
 	_, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
 	_, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})

@@ -1141,7 +1141,20 @@ func (srv TaskService) ListTask3(param *command.SearchTaskCommand) (map[string]i
 	if err != nil {
 	if err != nil {
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "统计任务反馈异常总数"+err.Error())
 		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "统计任务反馈异常总数"+err.Error())
 	}
 	}
-
+	var taskAnomalyList []*domain.TaskAnomaly
+	//获取异常的任务反馈记录
+	taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
+		"transactionContext": transactionContext,
+	})
+	for _, val := range taskListData {
+		_, listData, err := taskAnomalyRepo.Find(map[string]interface{}{
+			"taskId":  val.TaskId,
+			"is_last": 1,
+		})
+		if err == nil {
+			taskAnomalyList = append(taskAnomalyList, listData...)
+		}
+	}
 	taskResult := []*adapter.TaskItem{}
 	taskResult := []*adapter.TaskItem{}
 	taskStageRepo := factory.CreateTaskStageRepository(map[string]interface{}{
 	taskStageRepo := factory.CreateTaskStageRepository(map[string]interface{}{
 		"transactionContext": transactionContext,
 		"transactionContext": transactionContext,
@@ -1177,6 +1190,8 @@ func (srv TaskService) ListTask3(param *command.SearchTaskCommand) (map[string]i
 				RealCompletedAt:   "",
 				RealCompletedAt:   "",
 				IsRef:             false,
 				IsRef:             false,
 			},
 			},
+			AnomalyDesc: []string{},
+			Marks:       map[string]string{},
 		}
 		}
 		if val.LastStage.RealCompletedAt > 0 {
 		if val.LastStage.RealCompletedAt > 0 {
 			tk.LastStage.RealCompletedAt = time.Unix(int64(val.LastStage.RealCompletedAt), 0).Local().Format("2006-01-02")
 			tk.LastStage.RealCompletedAt = time.Unix(int64(val.LastStage.RealCompletedAt), 0).Local().Format("2006-01-02")
@@ -1221,6 +1236,28 @@ func (srv TaskService) ListTask3(param *command.SearchTaskCommand) (map[string]i
 			}
 			}
 		}
 		}
 		tk.GenStatusDescript()
 		tk.GenStatusDescript()
+		for _, val := range taskAnomalyList {
+			if tk.Id != val.TaskId {
+				continue
+			}
+			if val.Marks == nil {
+				val.Marks = map[string]string{}
+			}
+			r := val.Remark + ",该条异常已通知"
+			for _, val2 := range val.NoticeWho {
+				r += val2["name"] + " "
+			}
+			tk.AnomalyDesc = append(tk.AnomalyDesc, r)
+			switch val.Category {
+			case domain.AnomalyCategoryType1:
+				tk.Marks["a"] = val.Marks["a"]
+				tk.Marks["c"] = val.Marks["c"]
+			case domain.AnomalyCategoryType2:
+				tk.Marks["b"] = val.Marks["b"]
+			case domain.AnomalyCategoryType3:
+				tk.Marks["d"] = val.Marks["d"]
+			}
+		}
 		taskResult = append(taskResult, &tk)
 		taskResult = append(taskResult, &tk)
 	}
 	}
 	result := tool_funs.SimpleWrapGridMap(int64(taskCount), taskResult)
 	result := tool_funs.SimpleWrapGridMap(int64(taskCount), taskResult)

@@ -392,7 +392,61 @@ func (srv TaskService) ListTaskAnomaly3(param *command.ListTaskAnomalyCommand) (
 	return result, nil
 	return result, nil
 }
 }
 
 
+func (srv TaskService) UserSelect(param *command.UserSelectCommand) []adapter.UserItem {
+	transactionContext, err := factory.CreateTransactionContext(nil)
+	if err != nil {
+		return nil
+	}
+	if err := transactionContext.StartTransaction(); err != nil {
+		return nil
+	}
+	defer func() {
+		_ = transactionContext.RollbackTransaction()
+	}()
+
+	if param.SubLevel == 0 {
+		userRepo := factory.CreateUserRepository(map[string]interface{}{
+			"transactionContext": transactionContext,
+		})
+		_, userList, err := userRepo.Find(map[string]interface{}{
+			"companyId": param.CompanyId,
+		})
+		selectList := []adapter.UserItem{}
+		if err != nil {
+			return selectList
+		}
+		for _, val := range userList {
+			selectList = append(selectList, adapter.UserItem{
+				Id:   val.Id,
+				Name: val.Name,
+			})
+		}
+		return selectList
+	}
+
+	userDao := dao.NewUserDao(map[string]interface{}{
+		"transactionContext": transactionContext,
+	})
+	userList, err := userDao.AllChildUser(param.UserId)
+	selectList := []adapter.UserItem{}
+	if err != nil {
+		return selectList
+	}
+	for _, val := range userList {
+		selectList = append(selectList, adapter.UserItem{
+			Id:    int64(val.Id),
+			Name:  val.Name,
+			Level: val.Level,
+		})
+	}
+	if err := transactionContext.CommitTransaction(); err != nil {
+		return selectList
+	}
+	return selectList
+}
+
 // 对异常记录的操作标记
 // 对异常记录的操作标记
-func (srv TaskService) MarkTaskAnomaly() error {
-	return nil
+func (srv TaskService) MarkTaskAnomaly(param *command.MarkTaskAnomalyCommand) (map[string]string, error) {
+
+	return nil, nil
 }
 }

@@ -8,6 +8,12 @@ import (
 	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/utils/xtime"
 	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/utils/xtime"
 )
 )
 
 
+const (
+	AnomalyCategoryType1 int = 1 //里程碑异常
+	AnomalyCategoryType2 int = 2 //反馈异常
+	AnomalyCategoryType3 int = 3 //辅导异常
+)
+
 // 任务的异常记录
 // 任务的异常记录
 type TaskAnomaly struct {
 type TaskAnomaly struct {
 	Id             int
 	Id             int
@@ -16,7 +22,7 @@ type TaskAnomaly struct {
 	CompanyId      int                 `json:"companyId,string"`
 	CompanyId      int                 `json:"companyId,string"`
 	TaskId         int                 `json:"taskId,string"`       // 任务id
 	TaskId         int                 `json:"taskId,string"`       // 任务id
 	TaskRecordId   int                 `json:"taskRecordId,string"` // 任务反馈的进度
 	TaskRecordId   int                 `json:"taskRecordId,string"` // 任务反馈的进度
-	Category       int                 `json:"category"`            // 异常记录的分类 1 里程碑异常；2反馈异常 ；3 辅导异常
+	Category       int                 `json:"category"`            // 异常记录的分类 1里程碑异常;2反馈异常;3 辅导异常
 	CurrentStage   TaskStage           `json:"currentStage"`        // 计划进度的里程碑
 	CurrentStage   TaskStage           `json:"currentStage"`        // 计划进度的里程碑
 	LastStage      TaskStage           `json:"lastStage"`           // 实际进度完成的里程碑
 	LastStage      TaskStage           `json:"lastStage"`           // 实际进度完成的里程碑
 	TaskStageCheck TaskStage           `json:"taskStageCheck"`      // 当天任务反馈操作里程碑记录
 	TaskStageCheck TaskStage           `json:"taskStageCheck"`      // 当天任务反馈操作里程碑记录
@@ -27,6 +33,7 @@ type TaskAnomaly struct {
 	RecordBegin    int64               `json:"recordBegin"`         // 异常记录的开始时间
 	RecordBegin    int64               `json:"recordBegin"`         // 异常记录的开始时间
 	NoticeWho      []map[string]string `json:"noticeWho"`           // 异常记录消息通知的人
 	NoticeWho      []map[string]string `json:"noticeWho"`           // 异常记录消息通知的人
 	Marks          map[string]string   `json:"marks"`               // 已经操作的标记
 	Marks          map[string]string   `json:"marks"`               // 已经操作的标记
+	Remark         string              `json:"remark"`
 }
 }
 
 
 // 已点击“去更新”
 // 已点击“去更新”
@@ -57,7 +64,7 @@ func (t *TaskAnomaly) SetNoticeWho(u *User) {
 
 
 // 异常状况描述
 // 异常状况描述
 func (t *TaskAnomaly) AnomalyDesc() (str string) {
 func (t *TaskAnomaly) AnomalyDesc() (str string) {
-	nowTime := time.Now()
+	nowTime := t.CreatedAt
 	switch t.Category {
 	switch t.Category {
 	case 1:
 	case 1:
 		//里程碑异常
 		//里程碑异常
@@ -101,6 +108,7 @@ func (t *TaskAnomaly) AnomalyDesc() (str string) {
 
 
 		}
 		}
 	}
 	}
+	t.Remark = str
 	return str
 	return str
 }
 }
 
 

@@ -50,7 +50,7 @@ type TaskRecordRepository interface {
 // 是否是辅导异常
 // 是否是辅导异常
 func (r *TaskRecord) IsAssistAnomaly() bool {
 func (r *TaskRecord) IsAssistAnomaly() bool {
 	r.AssistContent = strings.TrimSpace(r.AssistContent)
 	r.AssistContent = strings.TrimSpace(r.AssistContent)
-	if r.AssistLevel == AssistLevel1 || r.AssistContent == "无" {
+	if r.AssistLevel == AssistLevel1 || r.AssistContent == "无" || len(r.AssistContent) == 0 {
 		return true
 		return true
 	}
 	}
 	return false
 	return false

@@ -9,11 +9,12 @@ import (
 // 任务的异常记录
 // 任务的异常记录
 type TaskAnomaly struct {
 type TaskAnomaly struct {
 	tableName      struct{}            `comment:"任务的异常记录" pg:"task_anomaly"`
 	tableName      struct{}            `comment:"任务的异常记录" pg:"task_anomaly"`
-	Id             int                 `pg:"id"`                   //
+	Id             int                 `pg:"id,pk"`                //
 	CreatedAt      time.Time           `pg:"created_at"`           //
 	CreatedAt      time.Time           `pg:"created_at"`           //
 	UpdatedAt      time.Time           `pg:"updated_at"`           //
 	UpdatedAt      time.Time           `pg:"updated_at"`           //
 	CompanyId      int                 `pg:"company_id"`           //
 	CompanyId      int                 `pg:"company_id"`           //
 	TaskId         int                 `pg:"task_id"`              // 任务id
 	TaskId         int                 `pg:"task_id"`              // 任务id
+	TaskRecordId   int                 `pg:"task_record_id"`       //
 	Category       int                 `pg:"category"`             // 异常任务的分类
 	Category       int                 `pg:"category"`             // 异常任务的分类
 	CurrentStage   domain.TaskStage    `pg:"current_stage"`        // 计划完成的里程碑
 	CurrentStage   domain.TaskStage    `pg:"current_stage"`        // 计划完成的里程碑
 	LastStage      domain.TaskStage    `pg:"last_stage"`           // 实际完成的里程碑
 	LastStage      domain.TaskStage    `pg:"last_stage"`           // 实际完成的里程碑
@@ -25,4 +26,5 @@ type TaskAnomaly struct {
 	RecordBegin    int64               `pg:"record_begin"`         // 异常记录的开始时间
 	RecordBegin    int64               `pg:"record_begin"`         // 异常记录的开始时间
 	NoticeWho      []map[string]string `pg:"notice_who"`           // 异常记录消息通知的人
 	NoticeWho      []map[string]string `pg:"notice_who"`           // 异常记录消息通知的人
 	Marks          map[string]string   `pg:"marks"`                // 已经操作的标记
 	Marks          map[string]string   `pg:"marks"`                // 已经操作的标记
+	Remark         string              `pg:"remark,use_zero"`
 }
 }

@@ -30,6 +30,7 @@ func (repo *TaskAnomalyRepository) TransformToDomain(d *models.TaskAnomaly) *dom
 		UpdatedAt:      d.UpdatedAt,
 		UpdatedAt:      d.UpdatedAt,
 		CompanyId:      d.CompanyId,
 		CompanyId:      d.CompanyId,
 		TaskId:         d.TaskId,
 		TaskId:         d.TaskId,
+		TaskRecordId:   d.TaskRecordId,
 		Category:       d.Category,
 		Category:       d.Category,
 		CurrentStage:   d.CurrentStage,
 		CurrentStage:   d.CurrentStage,
 		LastStage:      d.LastStage,
 		LastStage:      d.LastStage,
@@ -41,6 +42,7 @@ func (repo *TaskAnomalyRepository) TransformToDomain(d *models.TaskAnomaly) *dom
 		RecordBegin:    d.RecordBegin,
 		RecordBegin:    d.RecordBegin,
 		NoticeWho:      d.NoticeWho,
 		NoticeWho:      d.NoticeWho,
 		Marks:          d.Marks,
 		Marks:          d.Marks,
+		Remark:         d.Remark,
 	}
 	}
 }
 }
 
 
@@ -51,6 +53,7 @@ func (repo *TaskAnomalyRepository) Save(param *domain.TaskAnomaly) error {
 		UpdatedAt:      param.UpdatedAt,
 		UpdatedAt:      param.UpdatedAt,
 		CompanyId:      param.CompanyId,
 		CompanyId:      param.CompanyId,
 		TaskId:         param.TaskId,
 		TaskId:         param.TaskId,
+		TaskRecordId:   param.TaskRecordId,
 		Category:       param.Category,
 		Category:       param.Category,
 		CurrentStage:   param.CurrentStage,
 		CurrentStage:   param.CurrentStage,
 		LastStage:      param.LastStage,
 		LastStage:      param.LastStage,
@@ -62,6 +65,7 @@ func (repo *TaskAnomalyRepository) Save(param *domain.TaskAnomaly) error {
 		RecordBegin:    param.RecordBegin,
 		RecordBegin:    param.RecordBegin,
 		NoticeWho:      param.NoticeWho,
 		NoticeWho:      param.NoticeWho,
 		Marks:          param.Marks,
 		Marks:          param.Marks,
+		Remark:         param.Remark,
 	}
 	}
 	db := repo.transactionContext.PgTx
 	db := repo.transactionContext.PgTx
 	if m.Id == 0 {
 	if m.Id == 0 {

@@ -301,3 +301,37 @@ func (c *TaskController) TaskAnomalyList2() {
 	resp, err := srv.ListTaskAnomaly2(paramReq)
 	resp, err := srv.ListTaskAnomaly2(paramReq)
 	c.Response(resp, err)
 	c.Response(resp, err)
 }
 }
+
+// UserSelect 人员下拉选择
+func (c *TaskController) UserSelect() {
+	srv := service.NewTaskService()
+	paramReq := &command.UserSelectCommand{}
+	err := c.BindJSON(paramReq)
+	if err != nil {
+		e := application.ThrowError(application.ARG_ERROR, "json 解析错误"+err.Error())
+		c.Response(nil, e)
+		return
+	}
+	userReq := middlewares.GetUser(c.Ctx)
+	paramReq.CompanyId = int(userReq.CompanyId)
+	paramReq.UserId = int(userReq.UserId)
+	resp := srv.UserSelect(paramReq)
+	c.Response(resp, nil)
+}
+
+// 点击操作
+func (c *TaskController) TaskAnomalyMark() {
+	srv := service.NewTaskService()
+	paramReq := &command.MarkTaskAnomalyCommand{}
+	err := c.BindJSON(paramReq)
+	if err != nil {
+		e := application.ThrowError(application.ARG_ERROR, "json 解析错误"+err.Error())
+		c.Response(nil, e)
+		return
+	}
+	userReq := middlewares.GetUser(c.Ctx)
+	paramReq.CompanyId = int(userReq.CompanyId)
+	resp, err := srv.MarkTaskAnomaly(paramReq)
+	c.Response(resp, err)
+
+}

@@ -36,9 +36,11 @@ func init() {
 	web.AddNamespace(taskFontNS)
 	web.AddNamespace(taskFontNS)
 	taskAnomalyNS := web.NewNamespace("/v1/font",
 	taskAnomalyNS := web.NewNamespace("/v1/font",
 		web.NSBefore(filters.AllowCors(), middlewares.CheckFontToken()),
 		web.NSBefore(filters.AllowCors(), middlewares.CheckFontToken()),
-		web.NSCtrlPost("/task_anomaly/my_task", (*controllers.TaskController).TaskAnomalyList1),
-		web.NSCtrlPost("/task_anomaly/my_relation", (*controllers.TaskController).TaskAnomalyList3),
-		web.NSCtrlPost("/task_anomaly/my_sub", (*controllers.TaskController).TaskAnomalyList2),
+		web.NSCtrlPost("/task_anomaly/my_task", (*controllers.TaskController).TaskAnomalyList1),     //我负责的任务
+		web.NSCtrlPost("/task_anomaly/my_relation", (*controllers.TaskController).TaskAnomalyList3), //和我有关的任务
+		web.NSCtrlPost("/task_anomaly/my_sub", (*controllers.TaskController).TaskAnomalyList2),      //我的下级负责的任务
+		web.NSCtrlPost("/task_anomaly/select/user", (*controllers.TaskController).UserSelect),       //人员下拉选择列表
+		web.NSCtrlPost("/task_anomaly/marks", (*controllers.TaskController).TaskAnomalyMark),
 	)
 	)
 	web.AddNamespace(taskAnomalyNS)
 	web.AddNamespace(taskAnomalyNS)
 }
 }