allied-creation / performance · 提交

转到一个项目

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

日常保存

内嵌 并排对比
正在显示 6 个修改的文件 包含 468 行增加 和 172 行删除
... ... @@ -23,7 +23,7 @@ func (service *AuthService) MobileLogin(param *command.MobileLoginCommand) (map[
// 统一用户中心登录
authCodeReply, err := factory.UCenterApi().AppAuthCode(param.Credentials, param.Cuid, param.Cid)
if err != nil || !authCodeReply.IsOk() {
return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "统一用户中心认证失败")
return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "统一用户中心认证："+authCodeReply.Msg)
}
// 用户权限校验
// 登录平台ID，28-绩效管理后台 29-员工绩效
... ... @@ -97,7 +97,7 @@ func (srv *AuthService) Authorize(param *command.AuthorizeCommand) (map[string]i
// 统一用户中心登录
authCodeReply, err := factory.UCenterApi().AppAuthCode(param.Credentials, param.Cuid, param.Cid)
if err != nil || !authCodeReply.IsOk() {
return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "统一用户中心认证失败")
return nil, application.ThrowError(application.INTERNAL_SERVER_ERROR, "统一用户中心认证："+authCodeReply.Msg)
}
// 用户权限校验
// 登录平台ID， 29-员工绩效
... ...
... ... @@ -7,6 +7,7 @@ import (
"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 检查任务里程碑反馈， 记录异常情况
... ... @@ -33,39 +34,47 @@ func checkTaskRecordV2(param *domain.TaskRecord) error {
return nil
}
taskData := taskDataList[0]
//userDao := dao.NewUserDao(map[string]interface{}{"transactionContext": transactionContext})
// 反馈异常,里程碑异常, 辅导异常
// 检查反馈异常
if param.IsRemarkAnomaly() {
taskData.Anomaly += 1
// err = isAssessFlag(transactionContext, taskData)
// if err != nil {
// return err
// }
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 = domain.TaskWarn
err := isWarnFlag(transactionContext, taskData)
err := isWarnFlag(transactionContext, taskData, param)
if err != nil {
return err
}
} else {
} else if param.TaskStageCheck.Id > 0 {
taskData.WarnFlag = domain.TaskWarnNull
err := isNotWarnFlag(transactionContext, taskData, param)
if err != nil {
return err
}
}
// 检查辅导异常
if param.IsAssistAnomaly() {
taskData.AssistFlag += 1
err = isAssistFlag(transactionContext, taskData)
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)
... ... @@ -79,8 +88,31 @@ func checkTaskRecordV2(param *domain.TaskRecord) error {
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": 2,
"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])
return fmt.Errorf("取消里程碑异常:%s", err)
}
// 处理里程碑异常的情况
func isWarnFlag(transactionContext application.TransactionContext, taskData *domain.Task) error {
func isWarnFlag(transactionContext application.TransactionContext, taskData *domain.Task, taskRecord *domain.TaskRecord) error {
taskAnomalyRepo := factory.CreateTaskAnomalyRepository(map[string]interface{}{
"transactionContext": transactionContext,
})
... ... @@ -88,39 +120,146 @@ func isWarnFlag(transactionContext application.TransactionContext, taskData *dom
userRepo := factory.CreateUserRepository(map[string]interface{}{
"transactionContext": transactionContext,
})
_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
"isLast": 1,
"category": 2,
"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: taskData.Id,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
CompanyId: taskData.CompanyId,
TaskId: taskData.Id,
TaskRecordId: taskRecord.Id,
Category: 1,
CurrentStage: taskData.CurrentStage,
LastStage: taskData.LastStage,
TaskStageCheck: taskRecord.TaskStageCheck,
AssessFlag: 0,
WarnFlag: int(taskData.WarnFlag),
AssistFlag: 0,
IsLast: 1,
TaskLevel: taskData.LevelName,
TaskName: taskData.Name,
TaskAlias: taskData.Alias,
TaskSortBy: taskData.SortBy,
TaskEndTime: taskData.EndTime,
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)
}
}
// 异常就通知自己和上级
//获取任务Leader的数据
_, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
if err != nil {
return fmt.Errorf("获取任务Leader:%s", err)
}
if len(useList) == 0 {
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
}
// 取消辅导异常的情况
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": 3,
"limit": 1,
"taskId": taskData.Id,
})
if err != nil {
return fmt.Errorf("查询辅导异常的数据：%s", err)
}
if len(oldAnomaly) == 0 {
return nil
}
_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{"isLast": 1, "category": 2, "limit": 1})
oldAnomaly[0].IsLast = 2
err = taskAnomalyRepo.Save(oldAnomaly[0])
return fmt.Errorf("取消辅导异常:%s", err)
}
// 处理辅导异常的情况
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,
})
_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{
"isLast": 1,
"category": 3,
"limit": 1,
"taskId": taskData.Id,
})
if err != nil {
return fmt.Errorf("查询反馈异常的数据：%s", err)
return fmt.Errorf("查询辅导异常的数据：%s", err)
}
// 异常就通知自己和上级
// 辅导异常通知该条任务负责人的上级；辅导异常超过N天，通知任务负责人的上上级
anomalyDataTmp := domain.TaskAnomaly{
Id: taskData.Id,
CreatedAt: taskData.CreatedAt,
UpdatedAt: taskData.UpdatedAt,
CompanyId: taskData.CompanyId,
TaskId: taskData.Id,
Category: 1,
CurrentStage: taskData.CurrentStage,
LastStage: taskData.LastStage,
AssessFlag: 0,
WarnFlag: int(taskData.WarnFlag),
AssistFlag: 0,
IsLast: 1,
TaskLevel: taskData.LevelName,
TaskName: taskData.Name,
TaskAlias: taskData.Alias,
TaskSortBy: taskData.SortBy,
TaskEndTime: taskData.EndTime,
RecordBegin: time.Now().Unix(),
NoticeWho: []int64{taskData.Leader.Id, useList[0].ParentId},
Id: taskData.Id,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
CompanyId: taskData.CompanyId,
TaskId: taskData.Id,
Category: 3,
CurrentStage: taskData.CurrentStage,
LastStage: taskData.LastStage,
TaskStageCheck: taskRecord.TaskStageCheck,
AssessFlag: 0,
WarnFlag: 0,
AssistFlag: taskData.AssistFlag,
IsLast: 1,
TaskLevel: taskData.LevelName,
TaskName: taskData.Name,
TaskAlias: taskData.Alias,
TaskSortBy: taskData.SortBy,
TaskEndTime: taskData.EndTime,
RecordBegin: taskRecord.CreatedAt.Unix(),
NoticeWho: []map[string]string{},
Marks: map[string]string{
"a": "", "b": "", "c": "", "d": "",
},
... ... @@ -128,76 +267,119 @@ func isWarnFlag(transactionContext application.TransactionContext, taskData *dom
if len(oldAnomaly) > 0 {
anomalyDataTmp.RecordBegin = oldAnomaly[0].RecordBegin
anomalyDataTmp.WarnFlag = oldAnomaly[0].WarnFlag + 1
oldAnomaly[0].IsLast = 2
err = taskAnomalyRepo.Save(oldAnomaly[0])
if err != nil {
return fmt.Errorf("更新里程碑异常记录：%s", err)
}
}
//获取任务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
}
// 处理辅导异常的情况
func isAssistFlag(transactionContext application.TransactionContext, taskData *domain.Task) error {
// 取消反馈异常的情况
func isNotAssessFlag(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": 3,
"limit": 1,
"taskId": taskData.Id,
})
//获取任务Leader的数据
_, useList, err := userRepo.Find(map[string]interface{}{"id": taskData.Leader.Id, "limit": 1})
if err != nil {
return fmt.Errorf("获取任务Leader:%s", err)
return fmt.Errorf("查询辅导异常的数据：%s", err)
}
if len(useList) == 0 {
if len(oldAnomaly) == 0 {
return nil
}
_, oldAnomaly, err := taskAnomalyRepo.Find(map[string]interface{}{"isLast": 1, "category": 3, "limit": 1})
oldAnomaly[0].IsLast = 2
err = taskAnomalyRepo.Save(oldAnomaly[0])
return fmt.Errorf("取消辅导异常:%s", err)
}
// 处理反馈异常的情况
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": 2,
"limit": 1,
"taskId": taskData.Id,
})
if err != nil {
return fmt.Errorf("查询反馈异常的数据：%s", err)
}
// 辅导异常通知该条任务负责人的上级；辅导异常超过3天，通知任务负责人的上上级
//
anomalyDataTmp := domain.TaskAnomaly{
Id: taskData.Id,
CreatedAt: taskData.CreatedAt,
UpdatedAt: taskData.UpdatedAt,
CompanyId: taskData.CompanyId,
TaskId: taskData.Id,
Category: 3,
CurrentStage: taskData.CurrentStage,
LastStage: taskData.LastStage,
AssessFlag: 0,
WarnFlag: 0,
AssistFlag: taskData.AssistFlag,
IsLast: 1,
TaskLevel: taskData.LevelName,
TaskName: taskData.Name,
TaskAlias: taskData.Alias,
TaskSortBy: taskData.SortBy,
TaskEndTime: taskData.EndTime,
RecordBegin: time.Now().Unix(),
NoticeWho: []int64{useList[0].ParentId},
Id: taskData.Id,
CreatedAt: time.Now(),
UpdatedAt: time.Now(),
CompanyId: taskData.CompanyId,
TaskId: taskData.Id,
Category: 3,
CurrentStage: taskData.CurrentStage,
LastStage: taskData.LastStage,
TaskStageCheck: taskRecord.TaskStageCheck,
AssessFlag: taskData.Anomaly,
WarnFlag: 0,
AssistFlag: 0,
IsLast: 1,
TaskLevel: taskData.LevelName,
TaskName: taskData.Name,
TaskAlias: taskData.Alias,
TaskSortBy: taskData.SortBy,
TaskEndTime: taskData.EndTime,
RecordBegin: taskRecord.CreatedAt.Unix(),
NoticeWho: []map[string]string{},
Marks: map[string]string{
"a": "", "b": "", "c": "", "d": "",
},
}
if taskData.AssistFlag >= taskData.AssistFlagMax {
//通知任务负责人的上上级
_, useList2, err := userRepo.Find(map[string]interface{}{"id": useList[0].ParentId, "limit": 1})
if err != nil {
return fmt.Errorf("获取任务Leader:%s", err)
}
if len(useList2) > 0 {
anomalyDataTmp.NoticeWho = append(anomalyDataTmp.NoticeWho, useList2[0].Id)
}
}
if len(oldAnomaly) > 0 {
anomalyDataTmp.RecordBegin = oldAnomaly[0].RecordBegin
oldAnomaly[0].IsLast = 2
... ... @@ -206,6 +388,27 @@ func isAssistFlag(transactionContext application.TransactionContext, taskData *d
return fmt.Errorf("更新里程碑异常记录：%s", err)
}
}
// 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)
... ... @@ -213,8 +416,3 @@ func isAssistFlag(transactionContext application.TransactionContext, taskData *d
return nil
}
// 处理反馈异常的情况
func isAssessFlag(transactionContext application.TransactionContext, taskData *domain.Task) error {
return nil
}
... ...
package domain
import "time"
import (
"fmt"
"strconv"
"time"
"gitlab.fjmaimaimai.com/allied-creation/performance/pkg/utils/xtime"
)
// 任务的异常记录
type TaskAnomaly struct {
Id int
CreatedAt time.Time `json:"createdAt"`
UpdatedAt time.Time `json:"updatedAt"`
CompanyId int `json:"companyId,string"`
TaskId int `jsom:"taskId,string"` // 任务id
Category int `json:"category"` // 异常记录的分类 1 里程碑异常；2反馈异常 ；3 辅导异常
CurrentStage TaskStage `json:"currentStage"` // 当前执行的里程碑
LastStage TaskStage `json:"lastStage"` // 上一个完成的里程碑
AssessFlag int `json:"anomaly"` // 异常反馈的次数
WarnFlag int `json:"warnFlag"` // 里程碑异常次数
AssistFlag int `json:"assistFlag"` // 辅导异常次数
IsLast int `json:"isLast"` // 是否是最新的一条记录 1 是最新的记录 2 不是最新的记录
TaskLevel string `json:"taskLevel"` // 任务类型
TaskName string `json:"taskName"` // 任务名称
TaskAlias string `json:"taskAlias"` // 任务别名
TaskSortBy TaskSortBy `json:"taskSortBy"` // 优先级排序;值越小优先级越高
TaskEndTime int64 `json:"taskEndTime"` // 任务截止的时间戳，单位:秒；等于0时表示未设置时间
RecordBegin int64 `json:"recordBegin"` // 异常记录的开始时间
NoticeWho []int64 `json:"noticeWho"` // 异常记录消息通知的人
Marks map[string]string `json:"marks"` // 已经操作的标记
Id int
CreatedAt time.Time `json:"createdAt"`
UpdatedAt time.Time `json:"updatedAt"`
CompanyId int `json:"companyId,string"`
TaskId int `jsom:"taskId,string"` // 任务id
TaskRecordId int `json:"taskRecordId,string"` // 任务反馈的进度
Category int `json:"category"` // 异常记录的分类 1 里程碑异常；2反馈异常 ；3 辅导异常
CurrentStage TaskStage `json:"currentStage"` // 计划进度的里程碑
LastStage TaskStage `json:"lastStage"` // 实际进度完成的里程碑
TaskStageCheck TaskStage `json:"taskStageCheck"` // 当天任务反馈操作里程碑记录
AssessFlag int `json:"anomaly"` // 异常反馈的次数
WarnFlag int `json:"warnFlag"` // 里程碑异常次数
AssistFlag int `json:"assistFlag"` // 辅导异常次数
IsLast int `json:"isLast"` // 是否是最新的一条记录 1 是最新的记录 2 不是最新的记录
TaskLevel string `json:"taskLevel"` // 任务类型
TaskName string `json:"taskName"` // 任务名称
TaskAlias string `json:"taskAlias"` // 任务别名
TaskSortBy TaskSortBy `json:"taskSortBy"` // 优先级排序;值越小优先级越高
TaskEndTime int64 `json:"taskEndTime"` // 任务截止的时间戳，单位:秒；等于0时表示未设置时间
RecordBegin int64 `json:"recordBegin"` // 异常记录的开始时间
NoticeWho []map[string]string `json:"noticeWho"` // 异常记录消息通知的人
Marks map[string]string `json:"marks"` // 已经操作的标记
}
// 已点击“去更新”
... ... @@ -46,6 +54,68 @@ func (t *TaskAnomaly) MarkD() {
t.Marks["d"] = "已辅导"
}
func (t *TaskAnomaly) SetNoticeWho(u *User) {
t.NoticeWho = append(t.NoticeWho, map[string]string{
"id": strconv.Itoa(int(u.Id)), "name": u.Name,
})
}
// 异常状况描述
func (t *TaskAnomaly) AnomalyDesc() (str string) {
nowTime := time.Now()
switch t.Category {
case 1:
//里程碑异常
{
if t.TaskStageCheck.RealCompletedAt == 0 {
//逾期未完成
planCompletedAt := time.Unix(t.TaskStageCheck.PlanCompletedAt, 0)
subDay := xtime.SubDayAbs(nowTime, planCompletedAt)
str = fmt.Sprintf("里程碑%s已逾期%d天", t.TaskStageCheck.Name, subDay)
} else {
//逾期完成
planCompletedAt := time.Unix(t.TaskStageCheck.PlanCompletedAt, 0)
realCompletedAt := time.Unix(t.TaskStageCheck.RealCompletedAt, 0)
subDay := xtime.SubDayAbs(realCompletedAt, planCompletedAt)
str = fmt.Sprintf("里程碑%s逾期%d天完成", t.TaskStageCheck.Name, subDay)
}
}
case 2:
//反馈异常
{
recordBegin := time.Unix(t.RecordBegin, 0)
subDay := xtime.SubDayAbs(nowTime, recordBegin)
str = fmt.Sprintf(
"本任务自%s未正常反馈项目进度,已异常%d天",
recordBegin.Local().Format("2006-01-02"),
subDay,
)
}
case 3:
// 辅导异常
{
recordBegin := time.Unix(t.RecordBegin, 0)
subDay := xtime.SubDayAbs(nowTime, recordBegin)
str = fmt.Sprintf(
"本任务计划于%s完成辅导,已逾期%d天",
recordBegin.Local().Format("2006-01-02"),
subDay,
)
}
}
return str
}
// 发送异常后的天数
func (t *TaskAnomaly) CountAnomalyDay() int {
t1 := t.CreatedAt
t2 := time.Unix(t.RecordBegin, 0)
return xtime.SubDayAbs(t1, t2)
}
// 存储
type TaskAnomalyRepository interface {
Save(param *TaskAnomaly) error
... ...
... ... @@ -8,25 +8,26 @@ import (
// 任务的异常记录
type TaskAnomaly struct {
tableName struct{} `comment:"任务的异常记录" pg:"task_anomaly"`
Id int `pg:"id"`
CreatedAt time.Time `pg:"created_at"`
UpdatedAt time.Time `pg:"updated_at"`
CompanyId int `pg:"company_id"`
TaskId int `pg:"task_id"` // 任务id
Category int `pg:"category"` // 异常任务的分类
CurrentStage domain.TaskStage `pg:"current_stage"` // 当前执行的里程碑
LastStage domain.TaskStage `pg:"last_stage"` // 上一个完成的里程碑
AssessFlag int `pg:"assess_flag,use_zero"` // 异常反馈的次数
WarnFlag int `pg:"warn_flag,use_zero"` // 里程碑异常次数
AssistFlag int `pg:"assist_flag,use_zero"` // 辅导异常次数
IsLast int `pg:"is_last"` // 是否是最新的一条记录 1 是最新的记录 2 不是最新的记录
TaskLevel string `pg:"task_level"` // 任务类型
TaskName string `pg:"task_name"` // 任务名称
TaskAlias string `pg:"task_alias"` // 任务别名
TaskSortBy int `pg:"task_sort_by"` // 优先级排序;值越小优先级越高
TaskEndTime int64 `pg:"task_end_time,use_zero"` // 任务截止的时间戳，单位:秒；等于0时表示未设置时间
RecordBegin int64 `pg:"record_begin"` // 异常记录的开始时间
NoticeWho []int64 `pg:"notice_who"` // 异常记录消息通知的人
Marks map[string]string `pg:"marks"` // 已经操作的标记
tableName struct{} `comment:"任务的异常记录" pg:"task_anomaly"`
Id int `pg:"id"` //
CreatedAt time.Time `pg:"created_at"` //
UpdatedAt time.Time `pg:"updated_at"` //
CompanyId int `pg:"company_id"` //
TaskId int `pg:"task_id"` // 任务id
Category int `pg:"category"` // 异常任务的分类
CurrentStage domain.TaskStage `pg:"current_stage"` // 计划完成的里程碑
LastStage domain.TaskStage `pg:"last_stage"` // 实际完成的里程碑
TaskStageCheck domain.TaskStage `pg:"task_stage_check"` // 当天任务反馈操作里程碑记录
AssessFlag int `pg:"assess_flag,use_zero"` // 异常反馈的次数
WarnFlag int `pg:"warn_flag,use_zero"` // 里程碑异常次数
AssistFlag int `pg:"assist_flag,use_zero"` // 辅导异常次数
IsLast int `pg:"is_last"` // 是否是最新的一条记录 1 是最新的记录 2 不是最新的记录
TaskLevel string `pg:"task_level"` // 任务类型
TaskName string `pg:"task_name"` // 任务名称
TaskAlias string `pg:"task_alias"` // 任务别名
TaskSortBy int `pg:"task_sort_by"` // 优先级排序;值越小优先级越高
TaskEndTime int64 `pg:"task_end_time,use_zero"` // 任务截止的时间戳，单位:秒；等于0时表示未设置时间
RecordBegin int64 `pg:"record_begin"` // 异常记录的开始时间
NoticeWho []map[string]string `pg:"notice_who"` // 异常记录消息通知的人
Marks map[string]string `pg:"marks"` // 已经操作的标记
}
... ...
... ... @@ -4,7 +4,6 @@ import (
"errors"
"fmt"
"strconv"
"time"
"github.com/go-pg/pg/v10"
pgTransaction "github.com/linmadan/egglib-go/transaction/pg"
... ... @@ -26,55 +25,53 @@ func NewTaskAnomalyRepository(transactionContext *pgTransaction.TransactionConte
func (repo *TaskAnomalyRepository) TransformToDomain(d *models.TaskAnomaly) *domain.TaskAnomaly {
return &domain.TaskAnomaly{
Id: d.Id,
CreatedAt: d.CreatedAt,
UpdatedAt: d.UpdatedAt,
CompanyId: d.CompanyId,
TaskId: d.TaskId,
Category: d.Category,
CurrentStage: d.CurrentStage,
LastStage: d.LastStage,
AssessFlag: d.AssessFlag,
WarnFlag: d.WarnFlag,
AssistFlag: d.AssistFlag,
IsLast: d.IsLast,
TaskLevel: d.TaskLevel,
TaskName: d.TaskName,
TaskAlias: d.TaskAlias,
TaskSortBy: domain.TaskSortBy(d.TaskSortBy),
TaskEndTime: d.TaskEndTime,
RecordBegin: d.RecordBegin,
NoticeWho: d.NoticeWho,
Marks: d.Marks,
Id: d.Id,
CreatedAt: d.CreatedAt,
UpdatedAt: d.UpdatedAt,
CompanyId: d.CompanyId,
TaskId: d.TaskId,
Category: d.Category,
CurrentStage: d.CurrentStage,
LastStage: d.LastStage,
TaskStageCheck: d.TaskStageCheck,
AssessFlag: d.AssessFlag,
WarnFlag: d.WarnFlag,
AssistFlag: d.AssistFlag,
IsLast: d.IsLast,
TaskLevel: d.TaskLevel,
TaskName: d.TaskName,
TaskAlias: d.TaskAlias,
TaskSortBy: domain.TaskSortBy(d.TaskSortBy),
TaskEndTime: d.TaskEndTime,
RecordBegin: d.RecordBegin,
NoticeWho: d.NoticeWho,
Marks: d.Marks,
}
}
func (repo *TaskAnomalyRepository) Save(param *domain.TaskAnomaly) error {
param.UpdatedAt = time.Now()
if param.Id == 0 {
param.CreatedAt = time.Now()
}
m := models.TaskAnomaly{
Id: param.Id,
CreatedAt: param.CreatedAt,
UpdatedAt: param.UpdatedAt,
CompanyId: param.CompanyId,
TaskId: param.TaskId,
Category: param.Category,
CurrentStage: param.CurrentStage,
LastStage: param.LastStage,
AssessFlag: param.AssessFlag,
WarnFlag: param.WarnFlag,
AssistFlag: param.AssistFlag,
IsLast: param.IsLast,
TaskLevel: param.TaskLevel,
TaskName: param.TaskName,
TaskAlias: param.TaskAlias,
TaskSortBy: int(param.TaskSortBy),
TaskEndTime: param.TaskEndTime,
RecordBegin: param.RecordBegin,
NoticeWho: param.NoticeWho,
Marks: param.Marks,
Id: param.Id,
CreatedAt: param.CreatedAt,
UpdatedAt: param.UpdatedAt,
CompanyId: param.CompanyId,
TaskId: param.TaskId,
Category: param.Category,
CurrentStage: param.CurrentStage,
LastStage: param.LastStage,
TaskStageCheck: param.TaskStageCheck,
AssessFlag: param.AssessFlag,
WarnFlag: param.WarnFlag,
AssistFlag: param.AssistFlag,
IsLast: param.IsLast,
TaskLevel: param.TaskLevel,
TaskName: param.TaskName,
TaskAlias: param.TaskAlias,
TaskSortBy: int(param.TaskSortBy),
TaskEndTime: param.TaskEndTime,
RecordBegin: param.RecordBegin,
NoticeWho: param.NoticeWho,
Marks: param.Marks,
}
db := repo.transactionContext.PgTx
if m.Id == 0 {
... ... @@ -124,14 +121,17 @@ func (repo *TaskAnomalyRepository) Find(queryOptions map[string]interface{}) (in
query.Offset(offset)
}
}
if val, ok := queryOptions["taskId"]; ok {
query.Where(" task_id=? ", val)
}
if val, ok := queryOptions["category"]; ok {
query.Where(" category =? ", val)
}
if val, ok := queryOptions["currentStage"]; ok {
query.Where("current_stage @> ?", val)
if val, ok := queryOptions["taskStageCheck"]; ok {
query.Where(" task_stage_check @> ? ", val)
}
if val, ok := queryOptions["isLast"]; ok {
query.Where("is_last=?", val)
query.Where(" is_last=? ", val)
}
query.Order("id desc")
count, err := query.SelectAndCount()
... ...
package xtime
import "time"
// 当天的末尾时间, 例 2006-01-02 23:59:59
func DayEndTime(t time.Time) time.Time {
y, m, d := t.Local().Date()
t2 := time.Date(y, m, d, 23, 59, 59, 0, time.Local)
return t2
}
// 当天的0点时间 ,例 2006-01-02 00:00:00
func DayZeroTime(t time.Time) time.Time {
y, m, d := t.Local().Date()
t2 := time.Date(y, m, d, 0, 0, 0, 0, time.Local)
return t2
}
// 两个时间相差多少天
func SubDayAbs(t1, t2 time.Time) int {
day1 := DayZeroTime(t1)
day2 := DayZeroTime(t2)
t3 := day1.Sub(day2)
h := int(t3.Abs().Hours())
return (h / 24) + 1
}
... ...