allied-creation / performance · 提交

转到一个项目

作者 tangxvhui
提交 d5ba311a7d431432466002662b1dac5a791cad7e 1 个父辈 79c038a6

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

内嵌 并排对比
正在显示 5 个修改的文件 包含 780 行增加 和 446 行删除
... ... @@ -29,7 +29,7 @@ func CheckYesterdayTaskRecord() {
log.Logger.Info("获取每日任务反馈" + err.Error())
}
for _, val := range taskRecordList {
err = checkTaskRecordV2(val)
err = checkTaskRecordV3(val)
if err != nil {
log.Logger.Info("检查每日任务反馈" + err.Error())
}
... ...
... ... @@ -56,7 +56,7 @@ func TestCreatTaskAnamaly(t *testing.T) {
}
for _, val := range taskRacordList {
err = checkTaskRecordV2(val)
err = checkTaskRecordV3(val)
if err != nil {
log.Logger.Info("检查每日任务反馈" + err.Error())
}
... ...
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 检查任务里程碑反馈， 记录异常情况
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
import (
"strings"
"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
// }
... ...