allied-creation / performance · 提交

转到一个项目

作者 tangxvhui
提交 c5de3fed10ecbbbb3df435962b4db1d652ec70cb 1 个父辈 33f9aee3

日常保存

内嵌 并排对比
正在显示 6 个修改的文件 包含 468 行增加 和 172 行删除
@@ -23,7 +23,7 @@ func (service *AuthService) MobileLogin(param *command.MobileLoginCommand) (map[ @@ -23,7 +23,7 @@ func (service *AuthService) MobileLogin(param *command.MobileLoginCommand) (map[
23 // 统一用户中心登录 23 // 统一用户中心登录
24 authCodeReply, err := factory.UCenterApi().AppAuthCode(param.Credentials, param.Cuid, param.Cid) 24 authCodeReply, err := factory.UCenterApi().AppAuthCode(param.Credentials, param.Cuid, param.Cid)
25 if err != nil || !authCodeReply.IsOk() { 25 if err != nil || !authCodeReply.IsOk() {
26 - return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "统一用户中心认证失败") 26 + return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "统一用户中心认证："+authCodeReply.Msg)
27 } 27 }
28 // 用户权限校验 28 // 用户权限校验
29 // 登录平台ID，28-绩效管理后台 29-员工绩效 29 // 登录平台ID，28-绩效管理后台 29-员工绩效
@@ -97,7 +97,7 @@ func (srv *AuthService) Authorize(param *command.AuthorizeCommand) (map[string]i @@ -97,7 +97,7 @@ func (srv *AuthService) Authorize(param *command.AuthorizeCommand) (map[string]i
97 // 统一用户中心登录 97 // 统一用户中心登录
98 authCodeReply, err := factory.UCenterApi().AppAuthCode(param.Credentials, param.Cuid, param.Cid) 98 authCodeReply, err := factory.UCenterApi().AppAuthCode(param.Credentials, param.Cuid, param.Cid)
99 if err != nil || !authCodeReply.IsOk() { 99 if err != nil || !authCodeReply.IsOk() {
100 - return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "统一用户中心认证失败") 100 + return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "统一用户中心认证："+authCodeReply.Msg)
101 } 101 }
102 // 用户权限校验 102 // 用户权限校验
103 // 登录平台ID， 29-员工绩效 103 // 登录平台ID， 29-员工绩效
@@ -7,6 +7,7 @@ import ( @@ -7,6 +7,7 @@ import (
7 "github.com/linmadan/egglib-go/core/application" 7 "github.com/linmadan/egglib-go/core/application"
8 "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory" 8 "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/application/factory"
9 "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain" 9 "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/domain"
  10 + "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/utils/xtime"
10 ) 11 )
11 12
12 // TODO 检查任务里程碑反馈， 记录异常情况 13 // TODO 检查任务里程碑反馈， 记录异常情况
@@ -33,39 +34,47 @@ func checkTaskRecordV2(param *domain.TaskRecord) error { @@ -33,39 +34,47 @@ func checkTaskRecordV2(param *domain.TaskRecord) error {
33 return nil 34 return nil
34 } 35 }
35 taskData := taskDataList[0] 36 taskData := taskDataList[0]
36 -  
37 - //userDao := dao.NewUserDao(map[string]interface{}{"transactionContext": transactionContext})  
38 -  
39 - // 反馈异常,里程碑异常, 辅导异常  
40 // 检查反馈异常 37 // 检查反馈异常
41 if param.IsRemarkAnomaly() { 38 if param.IsRemarkAnomaly() {
42 taskData.Anomaly += 1 39 taskData.Anomaly += 1
43 - // err = isAssessFlag(transactionContext, taskData)  
44 - // if err != nil {  
45 - // return err  
46 - // } 40 + err = isAssessFlag(transactionContext, taskData, param)
  41 + if err != nil {
  42 + return err
  43 + }
47 } else { 44 } else {
48 taskData.Anomaly = 0 45 taskData.Anomaly = 0
  46 + err = isNotAssessFlag(transactionContext, taskData, param)
  47 + if err != nil {
  48 + return err
  49 + }
49 } 50 }
50 // 检查里程碑异常 51 // 检查里程碑异常
51 if param.IsTaskStageAnomaly() { 52 if param.IsTaskStageAnomaly() {
52 taskData.WarnFlag = domain.TaskWarn 53 taskData.WarnFlag = domain.TaskWarn
53 - err := isWarnFlag(transactionContext, taskData) 54 + err := isWarnFlag(transactionContext, taskData, param)
54 if err != nil { 55 if err != nil {
55 return err 56 return err
56 } 57 }
57 - } else { 58 + } else if param.TaskStageCheck.Id > 0 {
58 taskData.WarnFlag = domain.TaskWarnNull 59 taskData.WarnFlag = domain.TaskWarnNull
  60 + err := isNotWarnFlag(transactionContext, taskData, param)
  61 + if err != nil {
  62 + return err
  63 + }
59 } 64 }
60 // 检查辅导异常 65 // 检查辅导异常
61 if param.IsAssistAnomaly() { 66 if param.IsAssistAnomaly() {
62 taskData.AssistFlag += 1 67 taskData.AssistFlag += 1
63 - err = isAssistFlag(transactionContext, taskData) 68 + err = isAssistFlag(transactionContext, taskData, param)
64 if err != nil { 69 if err != nil {
65 return err 70 return err
66 } 71 }
67 } else { 72 } else {
68 taskData.AssistFlag = 0 73 taskData.AssistFlag = 0
  74 + err = isNotAssistFlag(transactionContext, taskData, param)
  75 + if err != nil {
  76 + return err
  77 + }
69 } 78 }
70 // 保存任务数据 79 // 保存任务数据
71 err = taskRepo.Save(taskData) 80 err = taskRepo.Save(taskData)
@@ -79,8 +88,31 @@ func checkTaskRecordV2(param *domain.TaskRecord) error { @@ -79,8 +88,31 @@ func checkTaskRecordV2(param *domain.TaskRecord) error {
79 return nil 88 return nil
80 } 89 }
81 90
  91 +// 取消里程碑异常
  92 +func isNotWarnFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
  93 + taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
  94 + "transactionContext": transactionContext,
  95 + })
  96 + _, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
  97 + "isLast": 1,
  98 + "category": 2,
  99 + "limit": 1,
  100 + "taskId": taskData.Id,
  101 + "taskStageCheck": fmt.Sprintf(`{"id":"%d"}`, taskRecord.TaskStageCheck.Id),
  102 + })
  103 + if err != nil {
  104 + return fmt.Errorf("查询里程碑异常的数据：%s", err)
  105 + }
  106 + if len(oldAnomaly) == 0 {
  107 + return nil
  108 + }
  109 + oldAnomaly[0].IsLast = 2
  110 + err = taskAnomalyRepo.Save(oldAnomaly[0])
  111 + return fmt.Errorf("取消里程碑异常:%s", err)
  112 +}
  113 +
82 // 处理里程碑异常的情况 114 // 处理里程碑异常的情况
83 -func isWarnFlag(transactionContext application.TransactionContext, taskData *domain.Task) error { 115 +func isWarnFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
84 taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{ 116 taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
85 "transactionContext": transactionContext, 117 "transactionContext": transactionContext,
86 }) 118 })
@@ -88,39 +120,146 @@ func isWarnFlag(transactionContext application.TransactionContext, taskData *dom @@ -88,39 +120,146 @@ func isWarnFlag(transactionContext application.TransactionContext, taskData *dom
88 userRepo := factory.CreateUserRepository(map[string]interface{}{ 120 userRepo := factory.CreateUserRepository(map[string]interface{}{
89 "transactionContext": transactionContext, 121 "transactionContext": transactionContext,
90 }) 122 })
  123 +
  124 + _, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
  125 + "isLast": 1,
  126 + "category": 2,
  127 + "limit": 1,
  128 + "taskId": taskData.Id,
  129 + "taskStageCheck": fmt.Sprintf(`{"id":"%d"}`, taskRecord.TaskStageCheck.Id),
  130 + })
  131 + if err != nil {
  132 + return fmt.Errorf("查询里程碑异常的数据：%s", err)
  133 + }
  134 +
  135 + anomalyDataTmp := domain.TaskAnomaly{
  136 + Id: taskData.Id,
  137 + CreatedAt: time.Now(),
  138 + UpdatedAt: time.Now(),
  139 + CompanyId: taskData.CompanyId,
  140 + TaskId: taskData.Id,
  141 + TaskRecordId: taskRecord.Id,
  142 + Category: 1,
  143 + CurrentStage: taskData.CurrentStage,
  144 + LastStage: taskData.LastStage,
  145 + TaskStageCheck: taskRecord.TaskStageCheck,
  146 + AssessFlag: 0,
  147 + WarnFlag: int(taskData.WarnFlag),
  148 + AssistFlag: 0,
  149 + IsLast: 1,
  150 + TaskLevel: taskData.LevelName,
  151 + TaskName: taskData.Name,
  152 + TaskAlias: taskData.Alias,
  153 + TaskSortBy: taskData.SortBy,
  154 + TaskEndTime: taskData.EndTime,
  155 + RecordBegin: taskRecord.CreatedAt.Unix(),
  156 + NoticeWho: []map[string]string{},
  157 + Marks: map[string]string{
  158 + "a": "", "b": "", "c": "", "d": "",
  159 + },
  160 + }
  161 + if len(oldAnomaly) > 0 {
  162 + anomalyDataTmp.WarnFlag = oldAnomaly[0].WarnFlag + 1
  163 + anomalyDataTmp.RecordBegin = oldAnomaly[0].RecordBegin
  164 + oldAnomaly[0].IsLast = 2
  165 + err = taskAnomalyRepo.Save(oldAnomaly[0])
  166 + if err != nil {
  167 + return fmt.Errorf("更新里程碑异常记录：%s", err)
  168 + }
  169 + }
  170 + // 异常就通知自己和上级
91 //获取任务Leader的数据 171 //获取任务Leader的数据
92 _, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1}) 172 _, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
93 if err != nil { 173 if err != nil {
94 return fmt.Errorf("获取任务Leader:%s", err) 174 return fmt.Errorf("获取任务Leader:%s", err)
95 } 175 }
96 - if len(useList) == 0 { 176 + var userParentId int64
  177 + if len(useList) > 0 {
  178 + anomalyDataTmp.SetNoticeWho(useList[0])
  179 + userParentId = useList[0].ParentId
  180 + }
  181 +
  182 + if userParentId > 0 {
  183 + // 获取上级用户的数据
  184 + _, useList2, err := userRepo.Find(map[string]interface{}{"id": userParentId, "limit": 1})
  185 + if err != nil {
  186 + return fmt.Errorf("获取任务Leader的上级:%s", err)
  187 + }
  188 + if len(useList2) > 0 {
  189 + anomalyDataTmp.SetNoticeWho(useList2[0])
  190 + }
  191 + }
  192 + err = taskAnomalyRepo.Save(&anomalyDataTmp)
  193 + if err != nil {
  194 + return fmt.Errorf("保存里程碑异常记录：%s", err)
  195 + }
  196 + return nil
  197 +}
  198 +
  199 +// 取消辅导异常的情况
  200 +func isNotAssistFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
  201 + taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
  202 + "transactionContext": transactionContext,
  203 + })
  204 +
  205 + _, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
  206 + "isLast": 1,
  207 + "category": 3,
  208 + "limit": 1,
  209 + "taskId": taskData.Id,
  210 + })
  211 + if err != nil {
  212 + return fmt.Errorf("查询辅导异常的数据：%s", err)
  213 + }
  214 + if len(oldAnomaly) == 0 {
97 return nil 215 return nil
98 } 216 }
99 - _, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{"isLast": 1, "category": 2, "limit": 1}) 217 + oldAnomaly[0].IsLast = 2
  218 + err = taskAnomalyRepo.Save(oldAnomaly[0])
  219 + return fmt.Errorf("取消辅导异常:%s", err)
  220 +}
  221 +
  222 +// 处理辅导异常的情况
  223 +func isAssistFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
  224 + taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
  225 + "transactionContext": transactionContext,
  226 + })
  227 +
  228 + userRepo := factory.CreateUserRepository(map[string]interface{}{
  229 + "transactionContext": transactionContext,
  230 + })
  231 +
  232 + _, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
  233 + "isLast": 1,
  234 + "category": 3,
  235 + "limit": 1,
  236 + "taskId": taskData.Id,
  237 + })
100 if err != nil { 238 if err != nil {
101 - return fmt.Errorf("查询反馈异常的数据：%s", err) 239 + return fmt.Errorf("查询辅导异常的数据：%s", err)
102 } 240 }
103 - // 异常就通知自己和上级 241 + // 辅导异常通知该条任务负责人的上级；辅导异常超过N天，通知任务负责人的上上级
104 anomalyDataTmp := domain.TaskAnomaly{ 242 anomalyDataTmp := domain.TaskAnomaly{
105 - Id: taskData.Id,  
106 - CreatedAt: taskData.CreatedAt,  
107 - UpdatedAt: taskData.UpdatedAt,  
108 - CompanyId: taskData.CompanyId,  
109 - TaskId: taskData.Id,  
110 - Category: 1,  
111 - CurrentStage: taskData.CurrentStage,  
112 - LastStage: taskData.LastStage,  
113 - AssessFlag: 0,  
114 - WarnFlag: int(taskData.WarnFlag),  
115 - AssistFlag: 0,  
116 - IsLast: 1,  
117 - TaskLevel: taskData.LevelName,  
118 - TaskName: taskData.Name,  
119 - TaskAlias: taskData.Alias,  
120 - TaskSortBy: taskData.SortBy,  
121 - TaskEndTime: taskData.EndTime,  
122 - RecordBegin: time.Now().Unix(),  
123 - NoticeWho: []int64{taskData.Leader.Id, useList[0].ParentId}, 243 + Id: taskData.Id,
  244 + CreatedAt: time.Now(),
  245 + UpdatedAt: time.Now(),
  246 + CompanyId: taskData.CompanyId,
  247 + TaskId: taskData.Id,
  248 + Category: 3,
  249 + CurrentStage: taskData.CurrentStage,
  250 + LastStage: taskData.LastStage,
  251 + TaskStageCheck: taskRecord.TaskStageCheck,
  252 + AssessFlag: 0,
  253 + WarnFlag: 0,
  254 + AssistFlag: taskData.AssistFlag,
  255 + IsLast: 1,
  256 + TaskLevel: taskData.LevelName,
  257 + TaskName: taskData.Name,
  258 + TaskAlias: taskData.Alias,
  259 + TaskSortBy: taskData.SortBy,
  260 + TaskEndTime: taskData.EndTime,
  261 + RecordBegin: taskRecord.CreatedAt.Unix(),
  262 + NoticeWho: []map[string]string{},
124 Marks: map[string]string{ 263 Marks: map[string]string{
125 "a": "", "b": "", "c": "", "d": "", 264 "a": "", "b": "", "c": "", "d": "",
126 }, 265 },
@@ -128,76 +267,119 @@ func isWarnFlag(transactionContext application.TransactionContext, taskData *dom @@ -128,76 +267,119 @@ func isWarnFlag(transactionContext application.TransactionContext, taskData *dom
128 267
129 if len(oldAnomaly) > 0 { 268 if len(oldAnomaly) > 0 {
130 anomalyDataTmp.RecordBegin = oldAnomaly[0].RecordBegin 269 anomalyDataTmp.RecordBegin = oldAnomaly[0].RecordBegin
131 - anomalyDataTmp.WarnFlag = oldAnomaly[0].WarnFlag + 1  
132 oldAnomaly[0].IsLast = 2 270 oldAnomaly[0].IsLast = 2
133 err = taskAnomalyRepo.Save(oldAnomaly[0]) 271 err = taskAnomalyRepo.Save(oldAnomaly[0])
134 if err != nil { 272 if err != nil {
135 return fmt.Errorf("更新里程碑异常记录：%s", err) 273 return fmt.Errorf("更新里程碑异常记录：%s", err)
136 } 274 }
137 } 275 }
  276 + //获取任务Leader的数据
  277 + _, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
  278 + if err != nil {
  279 + return fmt.Errorf("获取任务Leader:%s", err)
  280 + }
  281 + var userParentId int64
  282 + if len(useList) > 0 {
  283 + userParentId = useList[0].ParentId
  284 + }
  285 + if userParentId > 0 {
  286 + //通知任务负责人的上级
  287 + _, useList2, err := userRepo.Find(map[string]interface{}{"id": userParentId, "limit": 1})
  288 + if err != nil {
  289 + return fmt.Errorf("获取任务Leader:%s", err)
  290 + }
  291 + var userParentId2 int64
  292 + if len(useList2) > 0 {
  293 + anomalyDataTmp.SetNoticeWho(useList2[0])
  294 + userParentId2 = useList2[0].ParentId
  295 + }
  296 + // 辅导异常超过N天,通知任务负责人的上上级
  297 + if taskData.AssistFlag >= taskData.AssistFlagMax && userParentId2 > 0 {
  298 + _, useList3, err := userRepo.Find(map[string]interface{}{"id": userParentId, "limit": 1})
  299 + if err != nil {
  300 + return fmt.Errorf("获取任务Leader:%s", err)
  301 + }
  302 + if len(useList3) > 0 {
  303 + anomalyDataTmp.SetNoticeWho(useList3[0])
  304 + }
  305 + }
  306 + }
  307 +
138 err = taskAnomalyRepo.Save(&anomalyDataTmp) 308 err = taskAnomalyRepo.Save(&anomalyDataTmp)
139 if err != nil { 309 if err != nil {
140 return fmt.Errorf("保存里程碑异常记录：%s", err) 310 return fmt.Errorf("保存里程碑异常记录：%s", err)
141 } 311 }
142 return nil 312 return nil
  313 +
143 } 314 }
144 315
145 -// 处理辅导异常的情况  
146 -func isAssistFlag(transactionContext application.TransactionContext, taskData *domain.Task) error { 316 +// 取消反馈异常的情况
  317 +func isNotAssessFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
147 taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{ 318 taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
148 "transactionContext": transactionContext, 319 "transactionContext": transactionContext,
149 }) 320 })
150 321
151 - userRepo := factory.CreateUserRepository(map[string]interface{}{  
152 - "transactionContext": transactionContext, 322 + _, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
  323 + "isLast": 1,
  324 + "category": 3,
  325 + "limit": 1,
  326 + "taskId": taskData.Id,
153 }) 327 })
154 - //获取任务Leader的数据  
155 - _, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})  
156 if err != nil { 328 if err != nil {
157 - return fmt.Errorf("获取任务Leader:%s", err) 329 + return fmt.Errorf("查询辅导异常的数据：%s", err)
158 } 330 }
159 - if len(useList) == 0 { 331 + if len(oldAnomaly) == 0 {
160 return nil 332 return nil
161 } 333 }
162 - _, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{"isLast": 1, "category": 3, "limit": 1}) 334 + oldAnomaly[0].IsLast = 2
  335 + err = taskAnomalyRepo.Save(oldAnomaly[0])
  336 + return fmt.Errorf("取消辅导异常:%s", err)
  337 +
  338 +}
  339 +
  340 +// 处理反馈异常的情况
  341 +func isAssessFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
  342 + taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
  343 + "transactionContext": transactionContext,
  344 + })
  345 + userRepo := factory.CreateUserRepository(map[string]interface{}{
  346 + "transactionContext": transactionContext,
  347 + })
  348 + _, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
  349 + "isLast": 1,
  350 + "category": 2,
  351 + "limit": 1,
  352 + "taskId": taskData.Id,
  353 + })
163 if err != nil { 354 if err != nil {
164 return fmt.Errorf("查询反馈异常的数据：%s", err) 355 return fmt.Errorf("查询反馈异常的数据：%s", err)
165 } 356 }
166 - // 辅导异常通知该条任务负责人的上级；辅导异常超过3天，通知任务负责人的上上级 357 + //
167 anomalyDataTmp := domain.TaskAnomaly{ 358 anomalyDataTmp := domain.TaskAnomaly{
168 - Id: taskData.Id,  
169 - CreatedAt: taskData.CreatedAt,  
170 - UpdatedAt: taskData.UpdatedAt,  
171 - CompanyId: taskData.CompanyId,  
172 - TaskId: taskData.Id,  
173 - Category: 3,  
174 - CurrentStage: taskData.CurrentStage,  
175 - LastStage: taskData.LastStage,  
176 - AssessFlag: 0,  
177 - WarnFlag: 0,  
178 - AssistFlag: taskData.AssistFlag,  
179 - IsLast: 1,  
180 - TaskLevel: taskData.LevelName,  
181 - TaskName: taskData.Name,  
182 - TaskAlias: taskData.Alias,  
183 - TaskSortBy: taskData.SortBy,  
184 - TaskEndTime: taskData.EndTime,  
185 - RecordBegin: time.Now().Unix(),  
186 - NoticeWho: []int64{useList[0].ParentId}, 359 + Id: taskData.Id,
  360 + CreatedAt: time.Now(),
  361 + UpdatedAt: time.Now(),
  362 + CompanyId: taskData.CompanyId,
  363 + TaskId: taskData.Id,
  364 + Category: 3,
  365 + CurrentStage: taskData.CurrentStage,
  366 + LastStage: taskData.LastStage,
  367 + TaskStageCheck: taskRecord.TaskStageCheck,
  368 + AssessFlag: taskData.Anomaly,
  369 + WarnFlag: 0,
  370 + AssistFlag: 0,
  371 + IsLast: 1,
  372 + TaskLevel: taskData.LevelName,
  373 + TaskName: taskData.Name,
  374 + TaskAlias: taskData.Alias,
  375 + TaskSortBy: taskData.SortBy,
  376 + TaskEndTime: taskData.EndTime,
  377 + RecordBegin: taskRecord.CreatedAt.Unix(),
  378 + NoticeWho: []map[string]string{},
187 Marks: map[string]string{ 379 Marks: map[string]string{
188 "a": "", "b": "", "c": "", "d": "", 380 "a": "", "b": "", "c": "", "d": "",
189 }, 381 },
190 } 382 }
191 - if taskData.AssistFlag >= taskData.AssistFlagMax {  
192 - //通知任务负责人的上上级  
193 - _, useList2, err := userRepo.Find(map[string]interface{}{"id": useList[0].ParentId, "limit": 1})  
194 - if err != nil {  
195 - return fmt.Errorf("获取任务Leader:%s", err)  
196 - }  
197 - if len(useList2) > 0 {  
198 - anomalyDataTmp.NoticeWho = append(anomalyDataTmp.NoticeWho, useList2[0].Id)  
199 - }  
200 - }  
201 if len(oldAnomaly) > 0 { 383 if len(oldAnomaly) > 0 {
202 anomalyDataTmp.RecordBegin = oldAnomaly[0].RecordBegin 384 anomalyDataTmp.RecordBegin = oldAnomaly[0].RecordBegin
203 oldAnomaly[0].IsLast = 2 385 oldAnomaly[0].IsLast = 2
@@ -206,6 +388,27 @@ func isAssistFlag(transactionContext application.TransactionContext, taskData *d @@ -206,6 +388,27 @@ func isAssistFlag(transactionContext application.TransactionContext, taskData *d
206 return fmt.Errorf("更新里程碑异常记录：%s", err) 388 return fmt.Errorf("更新里程碑异常记录：%s", err)
207 } 389 }
208 } 390 }
  391 + // 2天未反馈通知被评估人自己；3天通知上级
  392 + // 获取任务Leader的数据
  393 + _, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
  394 + if err != nil {
  395 + return fmt.Errorf("获取任务Leader:%s", err)
  396 + }
  397 + var userParentId int64
  398 + if len(useList) > 0 {
  399 + anomalyDataTmp.SetNoticeWho(useList[0])
  400 + userParentId = useList[0].ParentId
  401 + }
  402 + anomalyDay := xtime.SubDayAbs(time.Now(), time.Unix(anomalyDataTmp.RecordBegin, 0))
  403 + if anomalyDay > 3 && userParentId > 0 {
  404 + _, useList2, err := userRepo.Find(map[string]interface{}{"id": userParentId, "limit": 1})
  405 + if err != nil {
  406 + return fmt.Errorf("获取任务Leader:%s", err)
  407 + }
  408 + if len(useList2) > 0 {
  409 + anomalyDataTmp.SetNoticeWho(useList2[0])
  410 + }
  411 + }
209 err = taskAnomalyRepo.Save(&anomalyDataTmp) 412 err = taskAnomalyRepo.Save(&anomalyDataTmp)
210 if err != nil { 413 if err != nil {
211 return fmt.Errorf("保存里程碑异常记录：%s", err) 414 return fmt.Errorf("保存里程碑异常记录：%s", err)
@@ -213,8 +416,3 @@ func isAssistFlag(transactionContext application.TransactionContext, taskData *d @@ -213,8 +416,3 @@ func isAssistFlag(transactionContext application.TransactionContext, taskData *d
213 return nil 416 return nil
214 417
215 } 418 }
216 -  
217 -// 处理反馈异常的情况  
218 -func isAssessFlag(transactionContext application.TransactionContext, taskData *domain.Task) error {  
219 - return nil  
220 -}  
1 package domain 1 package domain
2 2
3 -import "time" 3 +import (
  4 + "fmt"
  5 + "strconv"
  6 + "time"
  7 +
  8 + "gitlab.fjmaimaimai.com/allied-creation/performance/pkg/utils/xtime"
  9 +)
4 10
5 // 任务的异常记录 11 // 任务的异常记录
6 type TaskAnomaly struct { 12 type TaskAnomaly struct {
7 - Id int  
8 - CreatedAt time.Time `json:"createdAt"`  
9 - UpdatedAt time.Time `json:"updatedAt"`  
10 - CompanyId int `json:"companyId,string"`  
11 - TaskId int `jsom:"taskId,string"` // 任务id  
12 - Category int `json:"category"` // 异常记录的分类 1 里程碑异常；2反馈异常 ；3 辅导异常  
13 - CurrentStage TaskStage `json:"currentStage"` // 当前执行的里程碑  
14 - LastStage TaskStage `json:"lastStage"` // 上一个完成的里程碑  
15 - AssessFlag int `json:"anomaly"` // 异常反馈的次数  
16 - WarnFlag int `json:"warnFlag"` // 里程碑异常次数  
17 - AssistFlag int `json:"assistFlag"` // 辅导异常次数  
18 - IsLast int `json:"isLast"` // 是否是最新的一条记录 1 是最新的记录 2 不是最新的记录  
19 - TaskLevel string `json:"taskLevel"` // 任务类型  
20 - TaskName string `json:"taskName"` // 任务名称  
21 - TaskAlias string `json:"taskAlias"` // 任务别名  
22 - TaskSortBy TaskSortBy `json:"taskSortBy"` // 优先级排序;值越小优先级越高  
23 - TaskEndTime int64 `json:"taskEndTime"` // 任务截止的时间戳，单位:秒；等于0时表示未设置时间  
24 - RecordBegin int64 `json:"recordBegin"` // 异常记录的开始时间  
25 - NoticeWho []int64 `json:"noticeWho"` // 异常记录消息通知的人  
26 - Marks map[string]string `json:"marks"` // 已经操作的标记 13 + Id int
  14 + CreatedAt time.Time `json:"createdAt"`
  15 + UpdatedAt time.Time `json:"updatedAt"`
  16 + CompanyId int `json:"companyId,string"`
  17 + TaskId int `jsom:"taskId,string"` // 任务id
  18 + TaskRecordId int `json:"taskRecordId,string"` // 任务反馈的进度
  19 + Category int `json:"category"` // 异常记录的分类 1 里程碑异常；2反馈异常 ；3 辅导异常
  20 + CurrentStage TaskStage `json:"currentStage"` // 计划进度的里程碑
  21 + LastStage TaskStage `json:"lastStage"` // 实际进度完成的里程碑
  22 + TaskStageCheck TaskStage `json:"taskStageCheck"` // 当天任务反馈操作里程碑记录
  23 + AssessFlag int `json:"anomaly"` // 异常反馈的次数
  24 + WarnFlag int `json:"warnFlag"` // 里程碑异常次数
  25 + AssistFlag int `json:"assistFlag"` // 辅导异常次数
  26 + IsLast int `json:"isLast"` // 是否是最新的一条记录 1 是最新的记录 2 不是最新的记录
  27 + TaskLevel string `json:"taskLevel"` // 任务类型
  28 + TaskName string `json:"taskName"` // 任务名称
  29 + TaskAlias string `json:"taskAlias"` // 任务别名
  30 + TaskSortBy TaskSortBy `json:"taskSortBy"` // 优先级排序;值越小优先级越高
  31 + TaskEndTime int64 `json:"taskEndTime"` // 任务截止的时间戳，单位:秒；等于0时表示未设置时间
  32 + RecordBegin int64 `json:"recordBegin"` // 异常记录的开始时间
  33 + NoticeWho []map[string]string `json:"noticeWho"` // 异常记录消息通知的人
  34 + Marks map[string]string `json:"marks"` // 已经操作的标记
27 } 35 }
28 36
29 // 已点击“去更新” 37 // 已点击“去更新”
@@ -46,6 +54,68 @@ func (t *TaskAnomaly) MarkD() { @@ -46,6 +54,68 @@ func (t *TaskAnomaly) MarkD() {
46 t.Marks["d"] = "已辅导" 54 t.Marks["d"] = "已辅导"
47 } 55 }
48 56
  57 +func (t *TaskAnomaly) SetNoticeWho(u *User) {
  58 + t.NoticeWho = append(t.NoticeWho, map[string]string{
  59 + "id": strconv.Itoa(int(u.Id)), "name": u.Name,
  60 + })
  61 +}
  62 +
  63 +// 异常状况描述
  64 +func (t *TaskAnomaly) AnomalyDesc() (str string) {
  65 + nowTime := time.Now()
  66 + switch t.Category {
  67 + case 1:
  68 + //里程碑异常
  69 + {
  70 + if t.TaskStageCheck.RealCompletedAt == 0 {
  71 + //逾期未完成
  72 + planCompletedAt := time.Unix(t.TaskStageCheck.PlanCompletedAt, 0)
  73 + subDay := xtime.SubDayAbs(nowTime, planCompletedAt)
  74 + str = fmt.Sprintf("里程碑%s已逾期%d天", t.TaskStageCheck.Name, subDay)
  75 + } else {
  76 + //逾期完成
  77 + planCompletedAt := time.Unix(t.TaskStageCheck.PlanCompletedAt, 0)
  78 + realCompletedAt := time.Unix(t.TaskStageCheck.RealCompletedAt, 0)
  79 + subDay := xtime.SubDayAbs(realCompletedAt, planCompletedAt)
  80 + str = fmt.Sprintf("里程碑%s逾期%d天完成", t.TaskStageCheck.Name, subDay)
  81 +
  82 + }
  83 + }
  84 + case 2:
  85 + //反馈异常
  86 + {
  87 + recordBegin := time.Unix(t.RecordBegin, 0)
  88 + subDay := xtime.SubDayAbs(nowTime, recordBegin)
  89 + str = fmt.Sprintf(
  90 + "本任务自%s未正常反馈项目进度,已异常%d天",
  91 + recordBegin.Local().Format("2006-01-02"),
  92 + subDay,
  93 + )
  94 +
  95 + }
  96 + case 3:
  97 + // 辅导异常
  98 + {
  99 + recordBegin := time.Unix(t.RecordBegin, 0)
  100 + subDay := xtime.SubDayAbs(nowTime, recordBegin)
  101 + str = fmt.Sprintf(
  102 + "本任务计划于%s完成辅导,已逾期%d天",
  103 + recordBegin.Local().Format("2006-01-02"),
  104 + subDay,
  105 + )
  106 +
  107 + }
  108 + }
  109 + return str
  110 +}
  111 +
  112 +// 发送异常后的天数
  113 +func (t *TaskAnomaly) CountAnomalyDay() int {
  114 + t1 := t.CreatedAt
  115 + t2 := time.Unix(t.RecordBegin, 0)
  116 + return xtime.SubDayAbs(t1, t2)
  117 +}
  118 +
49 // 存储 119 // 存储
50 type TaskAnomalyRepository interface { 120 type TaskAnomalyRepository interface {
51 Save(param *TaskAnomaly) error 121 Save(param *TaskAnomaly) error
@@ -8,25 +8,26 @@ import ( @@ -8,25 +8,26 @@ import (
8 8
9 // 任务的异常记录 9 // 任务的异常记录
10 type TaskAnomaly struct { 10 type TaskAnomaly struct {
11 - tableName struct{} `comment:"任务的异常记录" pg:"task_anomaly"`  
12 - Id int `pg:"id"`  
13 - CreatedAt time.Time `pg:"created_at"`  
14 - UpdatedAt time.Time `pg:"updated_at"`  
15 - CompanyId int `pg:"company_id"`  
16 - TaskId int `pg:"task_id"` // 任务id  
17 - Category int `pg:"category"` // 异常任务的分类  
18 - CurrentStage domain.TaskStage `pg:"current_stage"` // 当前执行的里程碑  
19 - LastStage domain.TaskStage `pg:"last_stage"` // 上一个完成的里程碑  
20 - AssessFlag int `pg:"assess_flag,use_zero"` // 异常反馈的次数  
21 - WarnFlag int `pg:"warn_flag,use_zero"` // 里程碑异常次数  
22 - AssistFlag int `pg:"assist_flag,use_zero"` // 辅导异常次数  
23 - IsLast int `pg:"is_last"` // 是否是最新的一条记录 1 是最新的记录 2 不是最新的记录  
24 - TaskLevel string `pg:"task_level"` // 任务类型  
25 - TaskName string `pg:"task_name"` // 任务名称  
26 - TaskAlias string `pg:"task_alias"` // 任务别名  
27 - TaskSortBy int `pg:"task_sort_by"` // 优先级排序;值越小优先级越高  
28 - TaskEndTime int64 `pg:"task_end_time,use_zero"` // 任务截止的时间戳，单位:秒；等于0时表示未设置时间  
29 - RecordBegin int64 `pg:"record_begin"` // 异常记录的开始时间  
30 - NoticeWho []int64 `pg:"notice_who"` // 异常记录消息通知的人  
31 - Marks map[string]string `pg:"marks"` // 已经操作的标记 11 + tableName struct{} `comment:"任务的异常记录" pg:"task_anomaly"`
  12 + Id int `pg:"id"` //
  13 + CreatedAt time.Time `pg:"created_at"` //
  14 + UpdatedAt time.Time `pg:"updated_at"` //
  15 + CompanyId int `pg:"company_id"` //
  16 + TaskId int `pg:"task_id"` // 任务id
  17 + Category int `pg:"category"` // 异常任务的分类
  18 + CurrentStage domain.TaskStage `pg:"current_stage"` // 计划完成的里程碑
  19 + LastStage domain.TaskStage `pg:"last_stage"` // 实际完成的里程碑
  20 + TaskStageCheck domain.TaskStage `pg:"task_stage_check"` // 当天任务反馈操作里程碑记录
  21 + AssessFlag int `pg:"assess_flag,use_zero"` // 异常反馈的次数
  22 + WarnFlag int `pg:"warn_flag,use_zero"` // 里程碑异常次数
  23 + AssistFlag int `pg:"assist_flag,use_zero"` // 辅导异常次数
  24 + IsLast int `pg:"is_last"` // 是否是最新的一条记录 1 是最新的记录 2 不是最新的记录
  25 + TaskLevel string `pg:"task_level"` // 任务类型
  26 + TaskName string `pg:"task_name"` // 任务名称
  27 + TaskAlias string `pg:"task_alias"` // 任务别名
  28 + TaskSortBy int `pg:"task_sort_by"` // 优先级排序;值越小优先级越高
  29 + TaskEndTime int64 `pg:"task_end_time,use_zero"` // 任务截止的时间戳，单位:秒；等于0时表示未设置时间
  30 + RecordBegin int64 `pg:"record_begin"` // 异常记录的开始时间
  31 + NoticeWho []map[string]string `pg:"notice_who"` // 异常记录消息通知的人
  32 + Marks map[string]string `pg:"marks"` // 已经操作的标记
32 } 33 }
@@ -4,7 +4,6 @@ import ( @@ -4,7 +4,6 @@ import (
4 "errors" 4 "errors"
5 "fmt" 5 "fmt"
6 "strconv" 6 "strconv"
7 - "time"  
8 7
9 "github.com/go-pg/pg/v10" 8 "github.com/go-pg/pg/v10"
10 pgTransaction "github.com/linmadan/egglib-go/transaction/pg" 9 pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
@@ -26,55 +25,53 @@ func NewTaskAnomalyRepository(transactionContext *pgTransaction.TransactionConte @@ -26,55 +25,53 @@ func NewTaskAnomalyRepository(transactionContext *pgTransaction.TransactionConte
26 25
27 func (repo *TaskAnomalyRepository) TransformToDomain(d *models.TaskAnomaly) *domain.TaskAnomaly { 26 func (repo *TaskAnomalyRepository) TransformToDomain(d *models.TaskAnomaly) *domain.TaskAnomaly {
28 return &domain.TaskAnomaly{ 27 return &domain.TaskAnomaly{
29 - Id: d.Id,  
30 - CreatedAt: d.CreatedAt,  
31 - UpdatedAt: d.UpdatedAt,  
32 - CompanyId: d.CompanyId,  
33 - TaskId: d.TaskId,  
34 - Category: d.Category,  
35 - CurrentStage: d.CurrentStage,  
36 - LastStage: d.LastStage,  
37 - AssessFlag: d.AssessFlag,  
38 - WarnFlag: d.WarnFlag,  
39 - AssistFlag: d.AssistFlag,  
40 - IsLast: d.IsLast,  
41 - TaskLevel: d.TaskLevel,  
42 - TaskName: d.TaskName,  
43 - TaskAlias: d.TaskAlias,  
44 - TaskSortBy: domain.TaskSortBy(d.TaskSortBy),  
45 - TaskEndTime: d.TaskEndTime,  
46 - RecordBegin: d.RecordBegin,  
47 - NoticeWho: d.NoticeWho,  
48 - Marks: d.Marks, 28 + Id: d.Id,
  29 + CreatedAt: d.CreatedAt,
  30 + UpdatedAt: d.UpdatedAt,
  31 + CompanyId: d.CompanyId,
  32 + TaskId: d.TaskId,
  33 + Category: d.Category,
  34 + CurrentStage: d.CurrentStage,
  35 + LastStage: d.LastStage,
  36 + TaskStageCheck: d.TaskStageCheck,
  37 + AssessFlag: d.AssessFlag,
  38 + WarnFlag: d.WarnFlag,
  39 + AssistFlag: d.AssistFlag,
  40 + IsLast: d.IsLast,
  41 + TaskLevel: d.TaskLevel,
  42 + TaskName: d.TaskName,
  43 + TaskAlias: d.TaskAlias,
  44 + TaskSortBy: domain.TaskSortBy(d.TaskSortBy),
  45 + TaskEndTime: d.TaskEndTime,
  46 + RecordBegin: d.RecordBegin,
  47 + NoticeWho: d.NoticeWho,
  48 + Marks: d.Marks,
49 } 49 }
50 } 50 }
51 51
52 func (repo *TaskAnomalyRepository) Save(param *domain.TaskAnomaly) error { 52 func (repo *TaskAnomalyRepository) Save(param *domain.TaskAnomaly) error {
53 - param.UpdatedAt = time.Now()  
54 - if param.Id == 0 {  
55 - param.CreatedAt = time.Now()  
56 - }  
57 m := models.TaskAnomaly{ 53 m := models.TaskAnomaly{
58 - Id: param.Id,  
59 - CreatedAt: param.CreatedAt,  
60 - UpdatedAt: param.UpdatedAt,  
61 - CompanyId: param.CompanyId,  
62 - TaskId: param.TaskId,  
63 - Category: param.Category,  
64 - CurrentStage: param.CurrentStage,  
65 - LastStage: param.LastStage,  
66 - AssessFlag: param.AssessFlag,  
67 - WarnFlag: param.WarnFlag,  
68 - AssistFlag: param.AssistFlag,  
69 - IsLast: param.IsLast,  
70 - TaskLevel: param.TaskLevel,  
71 - TaskName: param.TaskName,  
72 - TaskAlias: param.TaskAlias,  
73 - TaskSortBy: int(param.TaskSortBy),  
74 - TaskEndTime: param.TaskEndTime,  
75 - RecordBegin: param.RecordBegin,  
76 - NoticeWho: param.NoticeWho,  
77 - Marks: param.Marks, 54 + Id: param.Id,
  55 + CreatedAt: param.CreatedAt,
  56 + UpdatedAt: param.UpdatedAt,
  57 + CompanyId: param.CompanyId,
  58 + TaskId: param.TaskId,
  59 + Category: param.Category,
  60 + CurrentStage: param.CurrentStage,
  61 + LastStage: param.LastStage,
  62 + TaskStageCheck: param.TaskStageCheck,
  63 + AssessFlag: param.AssessFlag,
  64 + WarnFlag: param.WarnFlag,
  65 + AssistFlag: param.AssistFlag,
  66 + IsLast: param.IsLast,
  67 + TaskLevel: param.TaskLevel,
  68 + TaskName: param.TaskName,
  69 + TaskAlias: param.TaskAlias,
  70 + TaskSortBy: int(param.TaskSortBy),
  71 + TaskEndTime: param.TaskEndTime,
  72 + RecordBegin: param.RecordBegin,
  73 + NoticeWho: param.NoticeWho,
  74 + Marks: param.Marks,
78 } 75 }
79 db := repo.transactionContext.PgTx 76 db := repo.transactionContext.PgTx
80 if m.Id == 0 { 77 if m.Id == 0 {
@@ -124,14 +121,17 @@ func (repo *TaskAnomalyRepository) Find(queryOptions map[string]interface{}) (in @@ -124,14 +121,17 @@ func (repo *TaskAnomalyRepository) Find(queryOptions map[string]interface{}) (in
124 query.Offset(offset) 121 query.Offset(offset)
125 } 122 }
126 } 123 }
  124 + if val, ok := queryOptions["taskId"]; ok {
  125 + query.Where(" task_id=? ", val)
  126 + }
127 if val, ok := queryOptions["category"]; ok { 127 if val, ok := queryOptions["category"]; ok {
128 query.Where(" category =? ", val) 128 query.Where(" category =? ", val)
129 } 129 }
130 - if val, ok := queryOptions["currentStage"]; ok {  
131 - query.Where("current_stage @> ?", val) 130 + if val, ok := queryOptions["taskStageCheck"]; ok {
  131 + query.Where(" task_stage_check @> ? ", val)
132 } 132 }
133 if val, ok := queryOptions["isLast"]; ok { 133 if val, ok := queryOptions["isLast"]; ok {
134 - query.Where("is_last=?", val) 134 + query.Where(" is_last=? ", val)
135 } 135 }
136 query.Order("id desc") 136 query.Order("id desc")
137 count, err := query.SelectAndCount() 137 count, err := query.SelectAndCount()
  1 +package xtime
  2 +
  3 +import "time"
  4 +
  5 +// 当天的末尾时间, 例 2006-01-02 23:59:59
  6 +func DayEndTime(t time.Time) time.Time {
  7 + y, m, d := t.Local().Date()
  8 + t2 := time.Date(y, m, d, 23, 59, 59, 0, time.Local)
  9 + return t2
  10 +}
  11 +
  12 +// 当天的0点时间 ,例 2006-01-02 00:00:00
  13 +func DayZeroTime(t time.Time) time.Time {
  14 + y, m, d := t.Local().Date()
  15 + t2 := time.Date(y, m, d, 0, 0, 0, 0, time.Local)
  16 + return t2
  17 +}
  18 +
  19 +// 两个时间相差多少天
  20 +func SubDayAbs(t1, t2 time.Time) int {
  21 + day1 := DayZeroTime(t1)
  22 + day2 := DayZeroTime(t2)
  23 +
  24 + t3 := day1.Sub(day2)
  25 + h := int(t3.Abs().Hours())
  26 + return (h / 24) + 1
  27 +}