调整列表输出

 package adapter
 package adapter
 
 
+// 任务异常记录列表
 type TaskAnomalyItem struct {
 type TaskAnomalyItem struct {
-	Id             int       `json:"id,string"`
-	TaskId         int       `json:"taskId,string"`       // 任务id
-	TaskRecordId   int       `json:"taskRecordId,string"` // 任务反馈记录id
-	Category       int       `json:"category"`            // 异常分类
-	Leader         string    `json:"leader"`              // 任务负责人
-	CurrentStage   TaskStage `json:"currentStage"`        // 计划进度的里程碑
-	LastStage      TaskStage `json:"lastStage"`           // 实际进度完成的里程碑
-	TaskStageCheck TaskStage `json:"taskStageCheck"`      // 实际进度完成的里程碑
-	AssessFlag     int       `json:"assessFlag"`          // 异常反馈的次数
-	WarnFlag       int       `json:"warnFlag"`            // 里程碑异常次数
-	AssistFlag     int       `json:"assistFlag"`          // 辅导异常次数
-	TaskLevel      string    `json:"taskLevel"`           // 任务类型
-	TaskName       string    `json:"taskName"`            // 任务名称
-	TaskAlias      string    `json:"taskAlias"`           // 任务别名
-	TaskEndTime    int64     `json:"taskEndTime"`         // 任务截止的时间戳，单位:秒；等于0时表示未设置时间
-	TaskSortBy     int       `json:"taskSortBy"`          // 优先级排序;值越小优先级越高
-	RecordBegin    int64     `json:"recordBegin"`         //
-	CreatedAt      string    `json:"createdAt"`
-	MarkA          string    `json:"markA"`       // 去更新
-	MarkB          string    `json:"markB"`       // 去反馈
-	MarkC          string    `json:"markC"`       // 去求助
-	MarkD          string    `json:"markD"`       // 去辅导
-	AnomalyDesc    string    `json:"anomalyDesc"` // 异常状况描述
+	Id             int               `json:"id,string"`
+	TaskId         int               `json:"taskId,string"`       // 任务id
+	TaskRecordId   int               `json:"taskRecordId,string"` // 任务反馈记录id
+	Category       int               `json:"category"`            // 异常分类
+	Leader         string            `json:"leader"`              // 任务负责人
+	CurrentStage   TaskStage         `json:"currentStage"`        // 计划进度的里程碑
+	LastStage      TaskStage         `json:"lastStage"`           // 实际进度完成的里程碑
+	TaskStageCheck TaskStage         `json:"taskStageCheck"`      // 实际进度完成的里程碑
+	AssessFlag     int               `json:"assessFlag"`          // 异常反馈的次数
+	WarnFlag       int               `json:"warnFlag"`            // 里程碑异常次数
+	AssistFlag     int               `json:"assistFlag"`          // 辅导异常次数
+	TaskLevel      string            `json:"taskLevel"`           // 任务类型
+	TaskName       string            `json:"taskName"`            // 任务名称
+	TaskAlias      string            `json:"taskAlias"`           // 任务别名
+	TaskEndTime    int64             `json:"taskEndTime"`         // 任务截止的时间戳，单位:秒；等于0时表示未设置时间
+	TaskSortBy     int               `json:"taskSortBy"`          // 优先级排序;值越小优先级越高
+	RecordBegin    int64             `json:"recordBegin"`         //
+	CreatedAt      string            `json:"createdAt"`           //
+	MarkA          string            `json:"markA"`               // 去更新
+	MarkB          string            `json:"markB"`               // 去反馈
+	MarkC          string            `json:"markC"`               // 去求助
+	MarkD          string            `json:"markD"`               // 去辅导
+	AnomalyDesc    string            `json:"anomalyDesc"`         // 异常状况描述
+	AnomalyDesc2   map[string]string `json:"anomalyDesc2"`
+}
+
+// 任务异常记录列表 ,按照任务负责人进行归类
+type TaskAnomalyItem2 struct {
+	Leader      map[string]string
+	TaskAnomaly []TaskAnomalyItem
 }
 }

@@ -2,6 +2,7 @@ package service
 
 
 import (
 import (
 	"fmt"
 	"fmt"
+	"strconv"
 	"time"
 	"time"
 
 
 	"github.com/linmadan/egglib-go/core/application"
 	"github.com/linmadan/egglib-go/core/application"
@@ -9,20 +10,21 @@ import (
 	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
 	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
 	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/task/adapter"
 	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/task/adapter"
 	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/task/command"
 	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/task/command"
+	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
 	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/dao"
 	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/infrastructure/dao"
 	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/utils/xtime"
 	"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/utils/xtime"
 )
 )
 
 
 // 异常中心查看
 // 异常中心查看
 
 
-// 我负责的任务，异常列表
-func (srv TaskService) ListTaskAnomaly1(param *command.ListTaskAnomalyCommand) (map[string]interface{}, error) {
+// 我的下级负责任务，异常列表
+func (srv TaskService) listTaskAnomaly2(param *command.ListTaskAnomalyCommand) (int64, []adapter.TaskAnomalyItem, error) {
 	transactionContext, err := factory.CreateTransactionContext(nil)
 	transactionContext, err := factory.CreateTransactionContext(nil)
 	if err != nil {
 	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
 	}
 	}
 	if err := transactionContext.StartTransaction(); err != nil {
 	if err := transactionContext.StartTransaction(); err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
 	}
 	}
 	defer func() {
 	defer func() {
 		_ = transactionContext.RollbackTransaction()
 		_ = transactionContext.RollbackTransaction()
@@ -32,16 +34,20 @@ func (srv TaskService) ListTaskAnomaly1(param *command.ListTaskAnomalyCommand) (
 	})
 	})
 	limit := 500
 	limit := 500
 	offset := 0
 	offset := 0
-	cnt, anomalyList, err := taskAnomalyDao.List1(param.UserId, param.CompanyId, param.TaskName, param.Category, param.DayTime, limit, offset)
+	if param.SubLevel < 1 {
+		param.SubLevel = 2
+	}
+	cnt, anomalyList, err := taskAnomalyDao.List2(param.UserId, param.CompanyId, param.TaskName, param.Category, param.DayTime, param.LeaderId, param.SubLevel, limit, offset)
 	if err != nil {
 	if err != nil {
-		return map[string]interface{}{}, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+		return 0, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	}
 
 
 	if err := transactionContext.CommitTransaction(); err != nil {
 	if err := transactionContext.CommitTransaction(); err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+		return 0, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	}
 
 
 	listData := []adapter.TaskAnomalyItem{}
 	listData := []adapter.TaskAnomalyItem{}
+
 	for _, val := range anomalyList {
 	for _, val := range anomalyList {
 		item := adapter.TaskAnomalyItem{
 		item := adapter.TaskAnomalyItem{
 			Id:           val.Id,
 			Id:           val.Id,
@@ -73,8 +79,8 @@ func (srv TaskService) ListTaskAnomaly1(param *command.ListTaskAnomalyCommand) (
 			TaskAlias:   val.TaskAlias,
 			TaskAlias:   val.TaskAlias,
 			TaskEndTime: int64(val.TaskEndTime),
 			TaskEndTime: int64(val.TaskEndTime),
 			TaskSortBy:  val.TaskSortBy,
 			TaskSortBy:  val.TaskSortBy,
-			CreatedAt:   val.CreatedAt.Local().Format("2006-01-02"),
 			RecordBegin: val.RecordBegin,
 			RecordBegin: val.RecordBegin,
+			CreatedAt:   val.CreatedAt.Local().Format("2006-01-02"),
 			MarkA:       "",
 			MarkA:       "",
 			MarkB:       "",
 			MarkB:       "",
 			MarkC:       "",
 			MarkC:       "",
@@ -101,12 +107,23 @@ func (srv TaskService) ListTaskAnomaly1(param *command.ListTaskAnomalyCommand) (
 					planCompletedAt := time.Unix(val.TaskStageCheck.PlanCompletedAt, 0)
 					planCompletedAt := time.Unix(val.TaskStageCheck.PlanCompletedAt, 0)
 					subDay := xtime.SubDayAbs(val.CreatedAt, planCompletedAt)
 					subDay := xtime.SubDayAbs(val.CreatedAt, planCompletedAt)
 					item.AnomalyDesc = fmt.Sprintf("里程碑%s已逾期%d天", val.TaskStageCheck.Name, subDay)
 					item.AnomalyDesc = fmt.Sprintf("里程碑%s已逾期%d天", val.TaskStageCheck.Name, subDay)
+					item.AnomalyDesc2 = map[string]string{
+						"types":     "10",
+						"stageName": val.TaskStageCheck.Name,
+						"interval":  strconv.Itoa(subDay),
+					}
+
 				} else if val.TaskStageCheck.RealCompletedAt > 0 && val.TaskStageCheck.Id > 0 {
 				} else if val.TaskStageCheck.RealCompletedAt > 0 && val.TaskStageCheck.Id > 0 {
 					//逾期完成
 					//逾期完成
 					planCompletedAt := time.Unix(val.TaskStageCheck.PlanCompletedAt, 0)
 					planCompletedAt := time.Unix(val.TaskStageCheck.PlanCompletedAt, 0)
 					realCompletedAt := time.Unix(val.TaskStageCheck.RealCompletedAt, 0)
 					realCompletedAt := time.Unix(val.TaskStageCheck.RealCompletedAt, 0)
 					subDay := xtime.SubDayAbs(realCompletedAt, planCompletedAt)
 					subDay := xtime.SubDayAbs(realCompletedAt, planCompletedAt)
 					item.AnomalyDesc = fmt.Sprintf("里程碑%s逾期%d天完成", val.TaskStageCheck.Name, subDay)
 					item.AnomalyDesc = fmt.Sprintf("里程碑%s逾期%d天完成", val.TaskStageCheck.Name, subDay)
+					item.AnomalyDesc2 = map[string]string{
+						"types":     "11",
+						"stageName": val.TaskStageCheck.Name,
+						"interval":  strconv.Itoa(subDay),
+					}
 				}
 				}
 			}
 			}
 		case 2:
 		case 2:
@@ -119,6 +136,11 @@ func (srv TaskService) ListTaskAnomaly1(param *command.ListTaskAnomalyCommand) (
 					recordBegin.Local().Format("2006-01-02"),
 					recordBegin.Local().Format("2006-01-02"),
 					subDay,
 					subDay,
 				)
 				)
+				item.AnomalyDesc2 = map[string]string{
+					"types":    "2",
+					"dayTime":  recordBegin.Local().Format("2006-01-02"),
+					"interval": strconv.Itoa(subDay),
+				}
 			}
 			}
 		case 3:
 		case 3:
 			//辅导异常
 			//辅导异常
@@ -130,24 +152,37 @@ func (srv TaskService) ListTaskAnomaly1(param *command.ListTaskAnomalyCommand) (
 					recordBegin.Local().Format("2006-01-02"),
 					recordBegin.Local().Format("2006-01-02"),
 					subDay,
 					subDay,
 				)
 				)
+				item.AnomalyDesc2 = map[string]string{
+					"types":    "3",
+					"dayTime":  recordBegin.Local().Format("2006-01-02"),
+					"interval": strconv.Itoa(subDay),
+				}
 			}
 			}
 		}
 		}
 
 
 		listData = append(listData, item)
 		listData = append(listData, item)
 	}
 	}
 
 
-	result := tool_funs.SimpleWrapGridMap(int64(cnt), listData)
-	return result, nil
+	return int64(cnt), listData, nil
 }
 }
 
 
-// 我的下级负责任务，异常列表
 func (srv TaskService) ListTaskAnomaly2(param *command.ListTaskAnomalyCommand) (map[string]interface{}, error) {
 func (srv TaskService) ListTaskAnomaly2(param *command.ListTaskAnomalyCommand) (map[string]interface{}, error) {
+	cnt, listData, err := srv.listTaskAnomaly2(param)
+	if err != nil {
+		return nil, err
+	}
+	result := tool_funs.SimpleWrapGridMap(cnt, listData)
+	return result, nil
+}
+
+// 与我有关的任务，异常列表
+func (srv TaskService) listTaskAnomaly3(param *command.ListTaskAnomalyCommand) (int64, []adapter.TaskAnomalyItem, error) {
 	transactionContext, err := factory.CreateTransactionContext(nil)
 	transactionContext, err := factory.CreateTransactionContext(nil)
 	if err != nil {
 	if err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
 	}
 	}
 	if err := transactionContext.StartTransaction(); err != nil {
 	if err := transactionContext.StartTransaction(); err != nil {
-		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
+		return 0, nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
 	}
 	}
 	defer func() {
 	defer func() {
 		_ = transactionContext.RollbackTransaction()
 		_ = transactionContext.RollbackTransaction()
@@ -157,16 +192,13 @@ func (srv TaskService) ListTaskAnomaly2(param *command.ListTaskAnomalyCommand) (
 	})
 	})
 	limit := 500
 	limit := 500
 	offset := 0
 	offset := 0
-	if param.SubLevel < 1 {
-		param.SubLevel = 2
-	}
-	cnt, anomalyList, err := taskAnomalyDao.List2(param.UserId, param.CompanyId, param.TaskName, param.Category, param.DayTime, param.LeaderId, param.SubLevel, limit, offset)
+	cnt, anomalyList, err := taskAnomalyDao.List3(param.UserId, param.CompanyId, param.TaskName, param.Category, param.DayTime, param.LeaderId, limit, offset)
 	if err != nil {
 	if err != nil {
-		return map[string]interface{}{}, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+		return 0, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	}
 
 
 	if err := transactionContext.CommitTransaction(); err != nil {
 	if err := transactionContext.CommitTransaction(); err != nil {
-		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+		return 0, nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	}
 
 
 	listData := []adapter.TaskAnomalyItem{}
 	listData := []adapter.TaskAnomalyItem{}
@@ -230,12 +262,22 @@ func (srv TaskService) ListTaskAnomaly2(param *command.ListTaskAnomalyCommand) (
 					planCompletedAt := time.Unix(val.TaskStageCheck.PlanCompletedAt, 0)
 					planCompletedAt := time.Unix(val.TaskStageCheck.PlanCompletedAt, 0)
 					subDay := xtime.SubDayAbs(val.CreatedAt, planCompletedAt)
 					subDay := xtime.SubDayAbs(val.CreatedAt, planCompletedAt)
 					item.AnomalyDesc = fmt.Sprintf("里程碑%s已逾期%d天", val.TaskStageCheck.Name, subDay)
 					item.AnomalyDesc = fmt.Sprintf("里程碑%s已逾期%d天", val.TaskStageCheck.Name, subDay)
+					item.AnomalyDesc2 = map[string]string{
+						"types":     "10",
+						"stageName": val.TaskStageCheck.Name,
+						"interval":  strconv.Itoa(subDay),
+					}
 				} else if val.TaskStageCheck.RealCompletedAt > 0 && val.TaskStageCheck.Id > 0 {
 				} else if val.TaskStageCheck.RealCompletedAt > 0 && val.TaskStageCheck.Id > 0 {
 					//逾期完成
 					//逾期完成
 					planCompletedAt := time.Unix(val.TaskStageCheck.PlanCompletedAt, 0)
 					planCompletedAt := time.Unix(val.TaskStageCheck.PlanCompletedAt, 0)
 					realCompletedAt := time.Unix(val.TaskStageCheck.RealCompletedAt, 0)
 					realCompletedAt := time.Unix(val.TaskStageCheck.RealCompletedAt, 0)
 					subDay := xtime.SubDayAbs(realCompletedAt, planCompletedAt)
 					subDay := xtime.SubDayAbs(realCompletedAt, planCompletedAt)
 					item.AnomalyDesc = fmt.Sprintf("里程碑%s逾期%d天完成", val.TaskStageCheck.Name, subDay)
 					item.AnomalyDesc = fmt.Sprintf("里程碑%s逾期%d天完成", val.TaskStageCheck.Name, subDay)
+					item.AnomalyDesc2 = map[string]string{
+						"types":     "11",
+						"stageName": val.TaskStageCheck.Name,
+						"interval":  strconv.Itoa(subDay),
+					}
 				}
 				}
 			}
 			}
 		case 2:
 		case 2:
@@ -248,6 +290,11 @@ func (srv TaskService) ListTaskAnomaly2(param *command.ListTaskAnomalyCommand) (
 					recordBegin.Local().Format("2006-01-02"),
 					recordBegin.Local().Format("2006-01-02"),
 					subDay,
 					subDay,
 				)
 				)
+				item.AnomalyDesc2 = map[string]string{
+					"types":    "2",
+					"dayTime":  recordBegin.Local().Format("2006-01-02"),
+					"interval": strconv.Itoa(subDay),
+				}
 			}
 			}
 		case 3:
 		case 3:
 			//辅导异常
 			//辅导异常
@@ -259,18 +306,84 @@ func (srv TaskService) ListTaskAnomaly2(param *command.ListTaskAnomalyCommand) (
 					recordBegin.Local().Format("2006-01-02"),
 					recordBegin.Local().Format("2006-01-02"),
 					subDay,
 					subDay,
 				)
 				)
+				item.AnomalyDesc2 = map[string]string{
+					"types":    "3",
+					"dayTime":  recordBegin.Local().Format("2006-01-02"),
+					"interval": strconv.Itoa(subDay),
+				}
 			}
 			}
 		}
 		}
 
 
 		listData = append(listData, item)
 		listData = append(listData, item)
 	}
 	}
+	return int64(cnt), listData, nil
+}
 
 
-	result := tool_funs.SimpleWrapGridMap(int64(cnt), listData)
+func (srv TaskService) ListTaskAnomaly3(param *command.ListTaskAnomalyCommand) (map[string]interface{}, error) {
+	cnt, listData, err := srv.listTaskAnomaly3(param)
+	if err != nil {
+		return nil, err
+	}
+	result := tool_funs.SimpleWrapGridMap(cnt, listData)
 	return result, nil
 	return result, nil
 }
 }
 
 
-// 与我有关的任务，异常列表
-func (srv TaskService) ListTaskAnomaly3(param *command.ListTaskAnomalyCommand) (map[string]interface{}, error) {
+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) ListTaskAnomaly1(param *command.ListTaskAnomalyCommand) (map[string]interface{}, error) {
 	transactionContext, err := factory.CreateTransactionContext(nil)
 	transactionContext, err := factory.CreateTransactionContext(nil)
 	if err != nil {
 	if err != nil {
 		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
 		return nil, application.ThrowError(application.TRANSACTION_ERROR, err.Error())
@@ -286,7 +399,7 @@ func (srv TaskService) ListTaskAnomaly3(param *command.ListTaskAnomalyCommand) (
 	})
 	})
 	limit := 500
 	limit := 500
 	offset := 0
 	offset := 0
-	cnt, anomalyList, err := taskAnomalyDao.List3(param.UserId, param.CompanyId, param.TaskName, param.Category, param.DayTime, param.LeaderId, limit, offset)
+	cnt, anomalyList, err := taskAnomalyDao.List1(param.UserId, param.CompanyId, param.TaskName, param.Category, param.DayTime, limit, offset)
 	if err != nil {
 	if err != nil {
 		return map[string]interface{}{}, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 		return map[string]interface{}{}, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
 	}
 	}
@@ -296,7 +409,6 @@ func (srv TaskService) ListTaskAnomaly3(param *command.ListTaskAnomalyCommand) (
 	}
 	}
 
 
 	listData := []adapter.TaskAnomalyItem{}
 	listData := []adapter.TaskAnomalyItem{}
-
 	for _, val := range anomalyList {
 	for _, val := range anomalyList {
 		item := adapter.TaskAnomalyItem{
 		item := adapter.TaskAnomalyItem{
 			Id:           val.Id,
 			Id:           val.Id,
@@ -320,20 +432,21 @@ func (srv TaskService) ListTaskAnomaly3(param *command.ListTaskAnomalyCommand) (
 				PlanCompletedAt:   time.Unix(val.LastStage.PlanCompletedAt, 0).Local().Format("2006-01-02"),
 				PlanCompletedAt:   time.Unix(val.LastStage.PlanCompletedAt, 0).Local().Format("2006-01-02"),
 				RealCompletedAt:   "",
 				RealCompletedAt:   "",
 			},
 			},
-			AssessFlag:  val.AssessFlag,
-			WarnFlag:    val.WarnFlag,
-			AssistFlag:  val.AssistFlag,
-			TaskLevel:   val.LevelName,
-			TaskName:    val.TaskName,
-			TaskAlias:   val.TaskAlias,
-			TaskEndTime: int64(val.TaskEndTime),
-			TaskSortBy:  val.TaskSortBy,
-			RecordBegin: val.RecordBegin,
-			CreatedAt:   val.CreatedAt.Local().Format("2006-01-02"),
-			MarkA:       "",
-			MarkB:       "",
-			MarkC:       "",
-			MarkD:       "",
+			AssessFlag:   val.AssessFlag,
+			WarnFlag:     val.WarnFlag,
+			AssistFlag:   val.AssistFlag,
+			TaskLevel:    val.LevelName,
+			TaskName:     val.TaskName,
+			TaskAlias:    val.TaskAlias,
+			TaskEndTime:  int64(val.TaskEndTime),
+			TaskSortBy:   val.TaskSortBy,
+			CreatedAt:    val.CreatedAt.Local().Format("2006-01-02"),
+			RecordBegin:  val.RecordBegin,
+			MarkA:        "",
+			MarkB:        "",
+			MarkC:        "",
+			MarkD:        "",
+			AnomalyDesc2: map[string]string{},
 		}
 		}
 		if len(val.Marks) > 0 {
 		if len(val.Marks) > 0 {
 			item.MarkA = val.Marks["a"]
 			item.MarkA = val.Marks["a"]
@@ -348,7 +461,7 @@ func (srv TaskService) ListTaskAnomaly3(param *command.ListTaskAnomalyCommand) (
 			item.LastStage.RealCompletedAt = time.Unix(val.LastStage.RealCompletedAt, 0).Local().Format("2006-01-02")
 			item.LastStage.RealCompletedAt = time.Unix(val.LastStage.RealCompletedAt, 0).Local().Format("2006-01-02")
 		}
 		}
 		switch val.Category {
 		switch val.Category {
-		case 1:
+		case domain.AnomalyCategoryType1:
 			{
 			{
 				//里程碑异常
 				//里程碑异常
 				if val.TaskStageCheck.RealCompletedAt == 0 && val.TaskStageCheck.Id > 0 {
 				if val.TaskStageCheck.RealCompletedAt == 0 && val.TaskStageCheck.Id > 0 {
@@ -356,15 +469,26 @@ func (srv TaskService) ListTaskAnomaly3(param *command.ListTaskAnomalyCommand) (
 					planCompletedAt := time.Unix(val.TaskStageCheck.PlanCompletedAt, 0)
 					planCompletedAt := time.Unix(val.TaskStageCheck.PlanCompletedAt, 0)
 					subDay := xtime.SubDayAbs(val.CreatedAt, planCompletedAt)
 					subDay := xtime.SubDayAbs(val.CreatedAt, planCompletedAt)
 					item.AnomalyDesc = fmt.Sprintf("里程碑%s已逾期%d天", val.TaskStageCheck.Name, subDay)
 					item.AnomalyDesc = fmt.Sprintf("里程碑%s已逾期%d天", val.TaskStageCheck.Name, subDay)
+					item.AnomalyDesc2 = map[string]string{
+						"types":     "10",
+						"stageName": val.TaskStageCheck.Name,
+						"interval":  strconv.Itoa(subDay),
+					}
+
 				} else if val.TaskStageCheck.RealCompletedAt > 0 && val.TaskStageCheck.Id > 0 {
 				} else if val.TaskStageCheck.RealCompletedAt > 0 && val.TaskStageCheck.Id > 0 {
 					//逾期完成
 					//逾期完成
 					planCompletedAt := time.Unix(val.TaskStageCheck.PlanCompletedAt, 0)
 					planCompletedAt := time.Unix(val.TaskStageCheck.PlanCompletedAt, 0)
 					realCompletedAt := time.Unix(val.TaskStageCheck.RealCompletedAt, 0)
 					realCompletedAt := time.Unix(val.TaskStageCheck.RealCompletedAt, 0)
 					subDay := xtime.SubDayAbs(realCompletedAt, planCompletedAt)
 					subDay := xtime.SubDayAbs(realCompletedAt, planCompletedAt)
 					item.AnomalyDesc = fmt.Sprintf("里程碑%s逾期%d天完成", val.TaskStageCheck.Name, subDay)
 					item.AnomalyDesc = fmt.Sprintf("里程碑%s逾期%d天完成", val.TaskStageCheck.Name, subDay)
+					item.AnomalyDesc2 = map[string]string{
+						"types":     "11",
+						"stageName": val.TaskStageCheck.Name,
+						"interval":  strconv.Itoa(subDay),
+					}
 				}
 				}
 			}
 			}
-		case 2:
+		case domain.AnomalyCategoryType2:
 			//反馈异常
 			//反馈异常
 			{
 			{
 				recordBegin := time.Unix(val.RecordBegin, 0)
 				recordBegin := time.Unix(val.RecordBegin, 0)
@@ -374,8 +498,13 @@ func (srv TaskService) ListTaskAnomaly3(param *command.ListTaskAnomalyCommand) (
 					recordBegin.Local().Format("2006-01-02"),
 					recordBegin.Local().Format("2006-01-02"),
 					subDay,
 					subDay,
 				)
 				)
+				item.AnomalyDesc2 = map[string]string{
+					"types":    "2",
+					"dayTime":  recordBegin.Local().Format("2006-01-02"),
+					"interval": strconv.Itoa(subDay),
+				}
 			}
 			}
-		case 3:
+		case domain.AnomalyCategoryType3:
 			//辅导异常
 			//辅导异常
 			{
 			{
 				recordBegin := time.Unix(val.RecordBegin, 0)
 				recordBegin := time.Unix(val.RecordBegin, 0)
@@ -385,6 +514,11 @@ func (srv TaskService) ListTaskAnomaly3(param *command.ListTaskAnomalyCommand) (
 					recordBegin.Local().Format("2006-01-02"),
 					recordBegin.Local().Format("2006-01-02"),
 					subDay,
 					subDay,
 				)
 				)
+				item.AnomalyDesc2 = map[string]string{
+					"types":    "3",
+					"dayTime":  recordBegin.Local().Format("2006-01-02"),
+					"interval": strconv.Itoa(subDay),
+				}
 			}
 			}
 		}
 		}
 
 
@@ -395,65 +529,6 @@ func (srv TaskService) ListTaskAnomaly3(param *command.ListTaskAnomalyCommand) (
 	return result, nil
 	return result, nil
 }
 }
 
 
-// 异常详情
-// func (srv TaskService) TaskAnomalyInfo() error {
-
-// 	return 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(param *command.MarkTaskAnomalyCommand) (map[string]string, error) {
 func (srv TaskService) MarkTaskAnomaly(param *command.MarkTaskAnomalyCommand) (map[string]string, error) {
 	transactionContext, err := factory.CreateTransactionContext(nil)
 	transactionContext, err := factory.CreateTransactionContext(nil)
@@ -501,13 +576,36 @@ func (srv TaskService) MarkTaskAnomaly(param *command.MarkTaskAnomalyCommand) (m
 	}
 	}
 
 
 	taskId := anomalyData.TaskId
 	taskId := anomalyData.TaskId
-	taskRepo.Find(map[string]interface{}{
-		"id": taskId,
+
+	// 检查是否有任务相关连的最新每日评估
+	_, taskList, err := taskRepo.Find(map[string]interface{}{
+		"id":        taskId,
+		"companyId": param.CompanyId,
+		"limit":     1,
 	})
 	})
-	//检查是否有任务相关连的最新每日评估
+	if err != nil {
+		return map[string]string{}, application.ThrowError(application.INTERNAL_SERVER_ERROR, err.Error())
+	}
+	if len(taskList) == 0 {
+		return map[string]string{}, nil
+	}
+	assessReps := factory.CreateStaffAssessRepository(map[string]interface{}{"transactionContext": transactionContext})
+	// 获取员工的评估
+	today := time.Now().Format("2006-01-02")
 
 
+	_, assessList, err := assessReps.Find(map[string]interface{}{
+		"companyId":  param.CompanyId,
+		"executorId": taskList[0].Leader.Id,
+		"beginDay":   today,
+		"typesList":  []string{string(domain.AssessSelf)},
+		"limit":      1,
+	})
+	if err != nil {
+		return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "获取员工的评估"+err.Error())
+	}
+	_ = assessList
 	if err := transactionContext.CommitTransaction(); err != nil {
 	if err := transactionContext.CommitTransaction(); err != nil {
 		return map[string]string{}, nil
 		return map[string]string{}, nil
 	}
 	}
-	return nil, nil
+	return map[string]string{}, nil
 }
 }

@@ -44,6 +44,7 @@ type ListTaskAnomaly struct {
 	TaskEndTime    int                 `pg:"task_end_time"`
 	TaskEndTime    int                 `pg:"task_end_time"`
 	TaskSortBy     int                 `pg:"task_sort_by"`
 	TaskSortBy     int                 `pg:"task_sort_by"`
 	LeaderName     string              `pg:"leader_name"`
 	LeaderName     string              `pg:"leader_name"`
+	LeaderId       string              `pg:"leader_id"`
 	LevelName      string              `pg:"level_name"`
 	LevelName      string              `pg:"level_name"`
 }
 }
 
 
@@ -78,6 +79,7 @@ func (d *TaskAnomalyDao) List1(userId int, companyId int, taskName string, categ
 	task.end_time as "task_end_time",
 	task.end_time as "task_end_time",
 	task.sort_by as "task_sort_by",
 	task.sort_by as "task_sort_by",
 	task.leader->>'name' as "leader_name",
 	task.leader->>'name' as "leader_name",
+	task.leader->>'id' as "leader_id",
 	task.level_name
 	task.level_name
 	from task_anomaly
 	from task_anomaly
 	join task on task.id = task_anomaly.task_id
 	join task on task.id = task_anomaly.task_id
@@ -168,6 +170,7 @@ func (d *TaskAnomalyDao) List2(userId int, companyId int, taskName string, categ
 		task.end_time as "task_end_time",
 		task.end_time as "task_end_time",
 		task.sort_by as "task_sort_by",
 		task.sort_by as "task_sort_by",
 		task.leader->>'name' as "leader_name",
 		task.leader->>'name' as "leader_name",
+		task.leader->>'id' as "leader_id",
 		task.level_name
 		task.level_name
 		from task 
 		from task 
 		left join t_task_ignore on task.id=t_task_ignore.task_id
 		left join t_task_ignore on task.id=t_task_ignore.task_id
@@ -180,7 +183,8 @@ func (d *TaskAnomalyDao) List2(userId int, companyId int, taskName string, categ
 	)
 	)
 	select 
 	select 
 	t_task.task_alias,t_task.task_name,t_task.task_end_time,
 	t_task.task_alias,t_task.task_name,t_task.task_end_time,
-	t_task.task_sort_by,t_task.leader_name,t_task.level_name,
+	t_task.task_sort_by,t_task.leader_name,t_task.leader_id,
+	t_task.level_name,
 	task_anomaly.id,
 	task_anomaly.id,
 	task_anomaly.task_id,
 	task_anomaly.task_id,
 	task_anomaly.task_record_id,
 	task_anomaly.task_record_id,
@@ -302,6 +306,7 @@ func (d *TaskAnomalyDao) List3(userId int, companyId int, taskName string, categ
 	task.end_time as "task_end_time",
 	task.end_time as "task_end_time",
 	task.sort_by as "task_sort_by",
 	task.sort_by as "task_sort_by",
 	task.leader->>'name' as "leader_name",
 	task.leader->>'name' as "leader_name",
+	task.leader->>'id' as "leader_id",
 	task.level_name
 	task.level_name
 	from task_anomaly
 	from task_anomaly
 	join task on task.id = task_anomaly.task_id
 	join task on task.id = task_anomaly.task_id