package services import ( "eta/eta_mobile/models" "eta/eta_mobile/models/report_approve" "eta/eta_mobile/models/smart_report" "eta/eta_mobile/services/alarm_msg" "eta/eta_mobile/utils" "fmt" "sort" "time" ) // GetReportClassifyTreeRecursive 递归获取报告分类树 func GetReportClassifyTreeRecursive(list []*models.Classify, parentId int) []*report_approve.ReportClassifyTreeItem { res := make([]*report_approve.ReportClassifyTreeItem, 0) for _, v := range list { if v.ParentId == parentId { t := new(report_approve.ReportClassifyTreeItem) t.ClassifyId = v.Id t.ClassifyName = v.ClassifyName t.ParentId = v.ParentId t.Children = GetReportClassifyTreeRecursive(list, v.Id) res = append(res, t) } } return res } // CheckReportApproveFlowChange 校验是否可变更分类 func CheckReportApproveFlowChange(reportType, classifyFirstId, classifySecondId, classifyThirdId int) (ok bool, err error) { var count int cond := ` AND classify_id_first = ? AND classify_id_second = ? AND state = ?` pars := make([]interface{}, 0) pars = append(pars, classifyFirstId, classifySecondId, models.ReportStateWaitApprove) switch reportType { case report_approve.FlowReportTypeChinese: cond += ` AND classify_id_third = ? ` pars = append(pars, classifyThirdId) ct, e := models.GetReportListCount(cond, pars) if e != nil { err = fmt.Errorf("GetReportListCount err: %s", e.Error()) return } count = ct case report_approve.FlowReportTypeEnglish: ct, e := models.GetEnglishReportListCount(cond, pars, "") if e != nil { err = fmt.Errorf("GetEnglishReportListCount err: %s", e.Error()) return } count = ct case report_approve.FlowReportTypeSmart: ob := new(smart_report.SmartReport) ct, e := ob.GetCountByCondition(cond, pars) if e != nil { err = fmt.Errorf("SmartReport GetCountByCondition err: %s", e.Error()) return } count = ct default: err = fmt.Errorf("报告类型有误") return } if count <= 0 { ok = true } return } // CheckReportOpenApprove 校验报告是否开启了审批流 func CheckReportOpenApprove(reportType, firstId, secondId, thirdId int) (opening bool, err error) { // 获取审批配置 confMap, e := models.GetBusinessConf() if e != nil { err = fmt.Errorf("GetBusinessConf err: %s", e.Error()) return } openMap := map[string]bool{"false": false, "true": true} openApprove := openMap[confMap[models.BusinessConfIsReportApprove]] // 查询对应分类是否有审批流 flowOb := new(report_approve.ReportApproveFlow) flowCond := fmt.Sprintf(` AND %s = ? AND %s = ? AND %s = ? AND %s = ?`, report_approve.ReportApproveFlowCols.ReportType, report_approve.ReportApproveFlowCols.ClassifyFirstId, report_approve.ReportApproveFlowCols.ClassifySecondId, report_approve.ReportApproveFlowCols.ClassifyThirdId) flowPars := make([]interface{}, 0) flowPars = append(flowPars, reportType, firstId, secondId, thirdId) flowItem, e := flowOb.GetItemByCondition(flowCond, flowPars, "") if e != nil && e.Error() != utils.ErrNoRow() { err = fmt.Errorf("ApproveFlow GetItemByCondition err: %s", e.Error()) return } // 开启审批/有审批流 if openApprove && (flowItem != nil || confMap[models.BusinessConfReportApproveType] == models.BusinessConfReportApproveTypeOther) { opening = true return } return } // CheckReportCurrState 校验报告当前应有的状态 func CheckReportCurrState(reportType, firstId, secondId, thirdId, operate int) (state int, err error) { // 获取审批配置 confMap, e := models.GetBusinessConf() if e != nil { err = fmt.Errorf("GetBusinessConf err: %s", e.Error()) return } openMap := map[string]bool{"false": false, "true": true} openApprove := openMap[confMap[models.BusinessConfIsReportApprove]] // 查询对应分类是否有审批流 flowOb := new(report_approve.ReportApproveFlow) flowCond := fmt.Sprintf(` AND %s = ? AND %s = ? AND %s = ? AND %s = ?`, report_approve.ReportApproveFlowCols.ReportType, report_approve.ReportApproveFlowCols.ClassifyFirstId, report_approve.ReportApproveFlowCols.ClassifySecondId, report_approve.ReportApproveFlowCols.ClassifyThirdId) flowPars := make([]interface{}, 0) flowPars = append(flowPars, reportType, firstId, secondId, thirdId) flowItem, e := flowOb.GetItemByCondition(flowCond, flowPars, "") if e != nil && e.Error() != utils.ErrNoRow() { err = fmt.Errorf("ApproveFlow GetItemByCondition err: %s", e.Error()) return } // 开启审批/有审批流 if openApprove && (flowItem != nil || confMap[models.BusinessConfReportApproveType] == models.BusinessConfReportApproveTypeOther) { // 操作为无审批的操作时, 会转为有审批的初始状态-待提交 stateMap := map[int]int{ models.ReportOperateAdd: models.ReportStateWaitSubmit, // 新增 models.ReportOperateEdit: models.ReportStateWaitSubmit, // 编辑 models.ReportOperatePublish: models.ReportStateWaitSubmit, // 发布 models.ReportOperateCancelPublish: models.ReportStateWaitSubmit, // 取消发布 models.ReportOperateSubmitApprove: models.ReportStateWaitApprove, // 提审 models.ReportOperateCancelApprove: models.ReportStateWaitSubmit, // 撤回 } state = stateMap[operate] return } // 关闭审批/分类无审批 // 操作为有审批的操作时, 会转为无审批的初始状态-未发布 stateMap := map[int]int{ models.ReportOperateAdd: models.ReportStateUnpublished, // 新增 models.ReportOperateEdit: models.ReportStateUnpublished, // 编辑 models.ReportOperatePublish: models.ReportStatePublished, // 发布 models.ReportOperateCancelPublish: models.ReportStateUnpublished, // 取消发布 models.ReportOperateSubmitApprove: models.ReportStateUnpublished, // 提审 models.ReportOperateCancelApprove: models.ReportStateUnpublished, // 撤回 } state = stateMap[operate] return } // SubmitReportApprove 提交审批 func SubmitReportApprove(reportType, reportId int, reportTitle string, firstId, secondId, thirdId int, sysAdminId int, sysAdminName string) (approveId int, err error) { // 默认内部审批, 如果是走的第三方审批, 那么仅修改状态 confMap, e := models.GetBusinessConf() if e != nil { err = fmt.Errorf("GetBusinessConf err: %s", e.Error()) return } openMap := map[string]bool{"false": false, "true": true} openApprove := openMap[confMap[models.BusinessConfIsReportApprove]] if !openApprove { err = fmt.Errorf("未开启审批") return } confApproveType := confMap[models.BusinessConfReportApproveType] if confApproveType == "" { confApproveType = models.BusinessConfReportApproveTypeEta } if confApproveType == models.BusinessConfReportApproveTypeOther { return } // 查询审批流 flowOb := new(report_approve.ReportApproveFlow) flowCond := fmt.Sprintf(` AND %s = ? AND %s = ? AND %s = ? AND %s = ?`, report_approve.ReportApproveFlowCols.ReportType, report_approve.ReportApproveFlowCols.ClassifyFirstId, report_approve.ReportApproveFlowCols.ClassifySecondId, report_approve.ReportApproveFlowCols.ClassifyThirdId) flowPars := make([]interface{}, 0) flowPars = append(flowPars, reportType, firstId, secondId, thirdId) flowItem, e := flowOb.GetItemByCondition(flowCond, flowPars, "") if e != nil { err = fmt.Errorf("ApproveFlow GetItemByCondition err: %s", e.Error()) return } // 查询审批节点 nodeOb := new(report_approve.ReportApproveNode) nodeCond := fmt.Sprintf(` AND %s = ? AND %s = ?`, report_approve.ReportApproveNodeCols.ReportApproveFlowId, report_approve.ReportApproveNodeCols.CurrVersion) nodePars := make([]interface{}, 0) nodePars = append(nodePars, flowItem.ReportApproveFlowId, flowItem.CurrVersion) nodeItems, e := nodeOb.GetItemsByCondition(nodeCond, nodePars, []string{}, "") if e != nil { err = fmt.Errorf("ApproveNodes GetItemsByCondition err: %s", e.Error()) return } if len(nodeItems) == 0 { err = fmt.Errorf("无审批节点") return } // 取出首个节点 firstNodeItem := new(report_approve.ReportApproveNode) for _, v := range nodeItems { if v.PrevNodeId == 0 { firstNodeItem = v continue } } if firstNodeItem == nil { err = fmt.Errorf("首个审批节点有误") return } // 审批信息 now := time.Now().Local() newApprove := new(report_approve.ReportApprove) newApprove.ReportType = reportType newApprove.ReportId = reportId newApprove.ReportTitle = reportTitle newApprove.ClassifyFirstId = firstId newApprove.ClassifySecondId = secondId newApprove.ClassifyThirdId = thirdId newApprove.State = report_approve.ReportApproveStateApproving newApprove.FlowId = flowItem.ReportApproveFlowId newApprove.FlowVersion = flowItem.CurrVersion newApprove.StartNodeId = firstNodeItem.ReportApproveNodeId newApprove.CurrNodeId = firstNodeItem.ReportApproveNodeId newApprove.ApplyUserId = sysAdminId newApprove.ApplyUserName = sysAdminName newApprove.CreateTime = now newApprove.ModifyTime = now if e = newApprove.Create(); e != nil { err = fmt.Errorf("生成审批信息失败, Err: %s", e.Error()) return } approveId = newApprove.ReportApproveId // 生成节点审批记录 err = BuildNextNodeRecordAndMsg(firstNodeItem, newApprove.ReportApproveId, sysAdminId, sysAdminName) return } // CancelReportApprove 撤回审批 func CancelReportApprove(reportType, reportId, approveId, sysAdminId int, sysAdminName string) (err error) { // 默认内部审批, 如果是走的第三方审批, 那么仅修改状态 confMap, e := models.GetBusinessConf() if e != nil { err = fmt.Errorf("GetBusinessConf err: %s", e.Error()) return } openMap := map[string]bool{"false": false, "true": true} openApprove := openMap[confMap[models.BusinessConfIsReportApprove]] if !openApprove { //err = fmt.Errorf("未开启审批") return } confApproveType := confMap[models.BusinessConfReportApproveType] if confApproveType == "" { confApproveType = models.BusinessConfReportApproveTypeEta } // 第三方审批仅修改报告状态 if confApproveType == models.BusinessConfReportApproveTypeOther { e = updateReportApproveState(reportType, reportId, 0, models.ReportStateWaitSubmit) if e != nil { err = fmt.Errorf("更新报告审批撤回失败, Err: %s", e.Error()) return } return } // 修改审批信息状态 approveOb := new(report_approve.ReportApprove) approveItem, e := approveOb.GetItemById(approveId) if e != nil { if e.Error() == utils.ErrNoRow() { return } err = fmt.Errorf("approve GetItemById err: %s", e.Error()) return } if approveItem.State == report_approve.ReportApproveStateCancel { return } approveItem.State = report_approve.ReportApproveStateCancel cols := []string{"State", "ModifyTime"} if e = approveItem.Update(cols); e != nil { err = fmt.Errorf("approve Update err: %s", e.Error()) return } // 修改报告状态 e = updateReportApproveState(reportType, reportId, 0, models.ReportStateWaitSubmit) if e != nil { err = fmt.Errorf("更新报告审批撤回失败, Err: %s", e.Error()) return } // 推送撤回消息 go func() { recordOb := new(report_approve.ReportApproveRecord) recordCond := fmt.Sprintf(` AND %s = ?`, report_approve.ReportApproveRecordCols.ReportApproveId) recordPars := make([]interface{}, 0) recordPars = append(recordPars, approveId) recordItems, e := recordOb.GetItemsByCondition(recordCond, recordPars, []string{}, "") if e != nil { utils.FileLog.Info(fmt.Sprintf("approve record GetItemsByCondition err: %s", e.Error())) return } messageOb := new(report_approve.ReportApproveMessage) messages := make([]*report_approve.ReportApproveMessage, 0) for _, v := range recordItems { m := new(report_approve.ReportApproveMessage) m.SendUserId = sysAdminId m.ReceiveUserId = v.ApproveUserId m.Content = fmt.Sprintf("%s提交的【研报审批】已撤回", sysAdminName) m.ReportApproveId = approveId m.ApproveState = report_approve.ReportApproveStateCancel m.CreateTime = time.Now().Local() m.ModifyTime = time.Now().Local() messages = append(messages, m) } e = messageOb.CreateMulti(messages) if e != nil { utils.FileLog.Info(fmt.Sprintf("CancelReportApprove messages err: %s", e.Error())) return } }() return } // updateReportApproveState 更新报告审批状态 func updateReportApproveState(reportType, reportId, approveId, state int) (err error) { updateCols := []string{"ApproveId", "State", "ModifyTime"} if reportType == report_approve.FlowReportTypeChinese { reportOb := new(models.Report) reportItem, e := reportOb.GetItemById(reportId) // 报告可能会被删除, 这里查不到就忽略掉 if e != nil && e.Error() != utils.ErrNoRow() { err = fmt.Errorf("获取中文研报失败, Err: %s", e.Error()) return } if reportItem != nil { reportItem.ApproveId = approveId reportItem.State = state reportItem.ModifyTime = time.Now().Local() if state == models.ReportStatePass || state == models.ReportStateRefused { updateCols = append(updateCols, "ApproveTime") reportItem.ApproveTime = time.Now().Local() } if state == models.ReportStatePass { updateCols = append(updateCols, "PublishTime") reportItem.PublishTime = time.Now().Local() } if e = reportItem.UpdateReport(updateCols); e != nil { err = fmt.Errorf("更新中文研报审批状态失败, Err: %s", e.Error()) return } } } if reportType == report_approve.FlowReportTypeEnglish { reportItem, e := models.GetEnglishReportItemById(reportId) if e != nil && e.Error() != utils.ErrNoRow() { err = fmt.Errorf("获取英文研报失败, Err: %s", e.Error()) return } if reportItem != nil { reportItem.ApproveId = approveId reportItem.State = state reportItem.ModifyTime = time.Now().Local() if state == models.ReportStatePass || state == models.ReportStateRefused { updateCols = append(updateCols, "ApproveTime") reportItem.ApproveTime = time.Now().Local() } if state == models.ReportStatePass { updateCols = append(updateCols, "PublishTime") reportItem.PublishTime = time.Now().Local() } if e = reportItem.UpdateReport(updateCols); e != nil { err = fmt.Errorf("更新英文研报审批状态失败, Err: %s", e.Error()) return } } } if reportType == report_approve.FlowReportTypeSmart { reportOb := new(smart_report.SmartReport) reportItem, e := reportOb.GetItemById(reportId) if e != nil && e.Error() != utils.ErrNoRow() { err = fmt.Errorf("获取智能研报失败, Err: %s", e.Error()) return } if reportItem != nil { reportItem.ApproveId = approveId reportItem.State = state reportItem.ModifyTime = time.Now().Local() if state == models.ReportStatePass || state == models.ReportStateRefused { updateCols = append(updateCols, "ApproveTime") reportItem.ApproveTime = time.Now().Local() } if state == models.ReportStatePass { updateCols = append(updateCols, "PublishTime") reportItem.PublishTime = time.Now().Local() } if e = reportItem.Update(updateCols); e != nil { err = fmt.Errorf("更新智能研报审批状态失败, Err: %s", e.Error()) return } } } return } // PassReportApprove 通过审批 func PassReportApprove(approveItem *report_approve.ReportApprove, recordItem *report_approve.ReportApproveRecord, sysAdminId int, reportUrl string) (tips string, err error) { if approveItem == nil { err = fmt.Errorf("审批信息有误") return } if recordItem == nil { err = fmt.Errorf("审批记录有误") return } // 查询审批流和审批流节点 flowOb := new(report_approve.ReportApproveFlow) flowItem, e := flowOb.GetItemById(approveItem.FlowId) if e != nil { err = fmt.Errorf("获取审批流失败, Err: %s", e.Error()) return } nodeOb := new(report_approve.ReportApproveNode) nodeCond := fmt.Sprintf(` AND %s = ? AND %s = ?`, report_approve.ReportApproveNodeCols.ReportApproveFlowId, report_approve.ReportApproveNodeCols.CurrVersion) nodePars := make([]interface{}, 0) nodePars = append(nodePars, flowItem.ReportApproveFlowId, flowItem.CurrVersion) nodeItems, e := nodeOb.GetItemsByCondition(nodeCond, nodePars, []string{}, "") if e != nil { err = fmt.Errorf("ApproveNodes GetItemsByCondition err: %s", e.Error()) return } if len(nodeItems) == 0 { err = fmt.Errorf("无审批节点") return } nodeMap := make(map[int]*report_approve.ReportApproveNode) for _, v := range nodeItems { nodeMap[v.ReportApproveNodeId] = v } // 取出审批记录的节点 currNodeItem := nodeMap[recordItem.NodeId] if currNodeItem == nil { err = fmt.Errorf("当前节点信息有误") return } currNode, e := report_approve.FormatReportApproveNode2Item(currNodeItem) if e != nil { err = fmt.Errorf("当前节点信息有误, Err: %s", e.Error()) return } now := time.Now().Local() recordItem.State = report_approve.ReportApproveStatePass recordItem.ApproveTime = now recordItem.ModifyTime = now recordItem.NodeState = report_approve.ReportApproveStatePass recordItem.NodeApproveUserId = recordItem.ApproveUserId recordItem.NodeApproveUserName = recordItem.ApproveUserName recordItem.NodeApproveTime = now recordCols := []string{"State", "ApproveTime", "ModifyTime", "NodeState", "NodeApproveUserId", "NodeApproveUserName", "NodeApproveTime"} lastApprove := false // 依次审批 if currNode.ApproveType == report_approve.NodeApproveTypeRoll { if e = recordItem.Update(recordCols); e != nil { err = fmt.Errorf("更新审批记录状态失败, Err: %s", e.Error()) return } // 检查依次审批情况 sort.Slice(currNode.Users, func(k, j int) bool { return currNode.Users[k].Sort < currNode.Users[j].Sort }) userLen := len(currNode.Users) //lastRoll := false nextUser := new(report_approve.ReportApproveNodeUserReq) // 下一个审批人, 为nil则表示当前审批人即为最后 for k, v := range currNode.Users { // 当前审批人 if v.UserId == sysAdminId && recordItem.ApproveUserSort == v.Sort { //if k == (userLen - 1) { // lastRoll = true // break //} if (k + 1) < userLen { nextUser = currNode.Users[k+1] } } } //if lastRoll && currNode.NextNodeId == 0 { // lastApprove = true //} // 当前节点下一个审批人, 生成下一个审批记录且return if nextUser.UserId > 0 { newRecord := new(report_approve.ReportApproveRecord) newRecord.ReportApproveId = recordItem.ReportApproveId newRecord.State = report_approve.ReportApproveStateApproving newRecord.NodeId = currNode.ReportApproveNodeId newRecord.PrevNodeId = currNode.PrevNodeId newRecord.NextNodeId = currNode.NextNodeId newRecord.ApproveType = currNode.ApproveType newRecord.ApproveUserId = nextUser.UserId newRecord.ApproveUserName = nextUser.UserName newRecord.ApproveUserSort = nextUser.Sort newRecord.CreateTime = now newRecord.ModifyTime = now newRecord.NodeState = report_approve.ReportApproveStateApproving if e = newRecord.Create(); e != nil { err = fmt.Errorf("生成审批记录失败, Err: %s", e.Error()) return } // 推送审批消息 go func() { messageItem := new(report_approve.ReportApproveMessage) messageItem.SendUserId = approveItem.ApplyUserId messageItem.ReceiveUserId = nextUser.UserId messageItem.Content = "您有新的待办任务" messageItem.Remark = fmt.Sprintf("%s提交的【研报审批】需要您审批，请及时处理", approveItem.ApplyUserName) messageItem.ReportApproveId = approveItem.ReportApproveId messageItem.ApproveState = report_approve.ReportApproveStateApproving messageItem.CreateTime = now messageItem.ModifyTime = now if e = messageItem.Create(); e != nil { utils.FileLog.Info(fmt.Sprintf("PassReportApprove message err: %s", e.Error())) return } }() return } // 更新审批当前节点并进入下一个节点 if currNode.NextNodeId > 0 { nextNode := nodeMap[currNode.NextNodeId] approveItem.CurrNodeId = currNode.NextNodeId approveItem.ModifyTime = now if e = approveItem.Update([]string{"CurrNodeId", "ModifyTime"}); e != nil { err = fmt.Errorf("更新审批当前节点失败, Err: %s", e.Error()) return } err = BuildNextNodeRecordAndMsg(nextNode, approveItem.ReportApproveId, approveItem.ApplyUserId, approveItem.ApplyUserName) return } else { // 最后一个节点 lastApprove = true } } // 会签 if currNode.ApproveType == report_approve.NodeApproveTypeAll { // 查询其他审批人是否已审批 otherOb := new(report_approve.ReportApproveRecord) otherCond := fmt.Sprintf(` AND %s = ? AND %s = ? AND %s <> ?`, report_approve.ReportApproveRecordCols.ReportApproveId, report_approve.ReportApproveRecordCols.NodeId, report_approve.ReportApproveRecordCols.ApproveUserId) otherPars := make([]interface{}, 0) otherPars = append(otherPars, approveItem.ReportApproveId, recordItem.NodeId, sysAdminId) otherRecords, e := otherOb.GetItemsByCondition(otherCond, otherPars, []string{}, "") if e != nil { err = fmt.Errorf("获取节点审批记录失败, Err: %s", e.Error()) return } otherPass := true for _, v := range otherRecords { if v.State != report_approve.ReportApproveStatePass { otherPass = false } } // 其他人未审批, 仅更新当前审批记录 if e = recordItem.Update(recordCols); e != nil { err = fmt.Errorf("更新审批记录状态失败, Err: %s", e.Error()) return } // 其他人已审批且为最后节点 if otherPass && currNode.NextNodeId == 0 { lastApprove = true } // 其他人已审批且不为最后节点, 进入下一节点 if otherPass && currNode.NextNodeId > 0 { nextNode := nodeMap[currNode.NextNodeId] approveItem.CurrNodeId = currNode.NextNodeId approveItem.ModifyTime = now if e = approveItem.Update([]string{"CurrNodeId", "ModifyTime"}); e != nil { err = fmt.Errorf("更新审批当前节点失败, Err: %s", e.Error()) return } err = BuildNextNodeRecordAndMsg(nextNode, approveItem.ReportApproveId, approveItem.ApplyUserId, approveItem.ApplyUserName) return } } // 或签 if currNode.ApproveType == report_approve.NodeApproveTypeAny { // 需检查一下审批的当前节点和记录的节点是否匹配, 不匹配可能是因为另外的审批人已通过, 所以此处应给提示 // 前端也有做相应的判断，但是两个人同时进入审批详情页时就可能出现这种情况 if approveItem.CurrNodeId != recordItem.NodeId { tips = "该节点已完成审批, 请刷新页面" return } if e = recordItem.Update(recordCols); e != nil { err = fmt.Errorf("更新审批记录状态失败, Err: %s", e.Error()) return } // 将该审批的同一个节点的记录标记为已审批 if e = recordItem.UpdateNodeState(recordItem.ReportApproveId, recordItem.NodeId, recordItem.NodeState, recordItem.NodeApproveUserId, recordItem.NodeApproveUserName, recordItem.NodeApproveTime); e != nil { err = fmt.Errorf("更新同一节点的其他审批记录状态失败, Err: %s", e.Error()) return } if currNode.NextNodeId == 0 { lastApprove = true } if currNode.NextNodeId > 0 { nextNode := nodeMap[currNode.NextNodeId] approveItem.CurrNodeId = currNode.NextNodeId approveItem.ModifyTime = now if e = approveItem.Update([]string{"CurrNodeId", "ModifyTime"}); e != nil { err = fmt.Errorf("更新审批当前节点失败, Err: %s", e.Error()) return } err = BuildNextNodeRecordAndMsg(nextNode, approveItem.ReportApproveId, approveItem.ApplyUserId, approveItem.ApplyUserName) return } } // 最后一个审批, 更新审批记录、审批、报告状态、推送消息给申请人 if lastApprove { if e = recordItem.Update(recordCols); e != nil { err = fmt.Errorf("更新审批记录状态失败, Err: %s", e.Error()) return } approveItem.State = report_approve.ReportApproveStatePass approveItem.ApproveTime = now approveItem.ModifyTime = now approveCols := []string{"State", "ApproveTime", "ModifyTime"} if e = approveItem.Update(approveCols); e != nil { err = fmt.Errorf("更新审批信息失败, Err: %s", e.Error()) return } if e = updateReportApproveState(approveItem.ReportType, approveItem.ReportId, approveItem.ReportApproveId, models.ReportStatePass); e != nil { err = fmt.Errorf("更新报告审批状态失败, Err: %s", e.Error()) return } go func() { messageItem := new(report_approve.ReportApproveMessage) messageItem.SendUserId = sysAdminId messageItem.ReceiveUserId = approveItem.ApplyUserId messageItem.Content = "您提交的审批已通过" messageItem.Remark = "您提交的【研报审批】已通过" messageItem.ReportApproveId = approveItem.ReportApproveId messageItem.ApproveState = report_approve.ReportApproveStatePass messageItem.CreateTime = now messageItem.ModifyTime = now if e = messageItem.Create(); e != nil { utils.FileLog.Info(fmt.Sprintf("PassReportApprove message err: %s", e.Error())) return } }() // 审批通过之后的处理 go func() { if e = AfterReportApprovePass(approveItem.ReportType, approveItem.ReportId); e != nil { utils.FileLog.Info(fmt.Sprintf("AfterReportApprovePass err: %s, ReportType: %d, ReportId: %d", e.Error(), approveItem.ReportType, approveItem.ReportId)) return } }() } return } // RefuseReportApprove 驳回审批 func RefuseReportApprove(approveItem *report_approve.ReportApprove, recordItem *report_approve.ReportApproveRecord, approveRemark string, sysAdminId int) (err error) { if approveItem == nil { err = fmt.Errorf("审批信息有误") return } if recordItem == nil { err = fmt.Errorf("审批记录有误") return } // 更新审批记录 now := time.Now().Local() recordItem.State = report_approve.ReportApproveStateRefuse recordItem.ApproveRemark = approveRemark recordItem.ApproveTime = now recordItem.ModifyTime = now recordItem.NodeState = report_approve.ReportApproveStateRefuse recordItem.NodeApproveUserId = recordItem.ApproveUserId recordItem.NodeApproveUserName = recordItem.ApproveUserName recordItem.NodeApproveTime = now recordCols := []string{"State", "ApproveRemark", "ApproveTime", "ModifyTime", "NodeState", "NodeApproveUserId", "NodeApproveUserName", "NodeApproveTime"} if e := recordItem.Update(recordCols); e != nil { err = fmt.Errorf("更新审批记录状态失败, Err: %s", e.Error()) return } // 将该审批的同一个节点的记录标记为已审批 if e := recordItem.UpdateNodeState(recordItem.ReportApproveId, recordItem.NodeId, recordItem.NodeState, recordItem.NodeApproveUserId, recordItem.NodeApproveUserName, recordItem.NodeApproveTime); e != nil { err = fmt.Errorf("更新同一节点的其他审批记录状态失败, Err: %s", e.Error()) return } // 驳回-更新审批, 报告状态, 推送消息 approveItem.State = report_approve.ReportApproveStateRefuse approveItem.ApproveRemark = approveRemark approveItem.ApproveTime = now approveItem.ModifyTime = now approveCols := []string{"State", "ApproveRemark", "ApproveTime", "ModifyTime"} if e := approveItem.Update(approveCols); e != nil { err = fmt.Errorf("更新审批状态失败, Err: %s", e.Error()) return } if e := updateReportApproveState(approveItem.ReportType, approveItem.ReportId, approveItem.ReportApproveId, models.ReportStateRefused); e != nil { err = fmt.Errorf("更新报告状态失败, Err: %s", e.Error()) return } // 推送驳回消息给申请人 go func() { messageItem := new(report_approve.ReportApproveMessage) messageItem.SendUserId = sysAdminId messageItem.ReceiveUserId = approveItem.ApplyUserId messageItem.Content = "您提交的审批被驳回" messageItem.Remark = "您提交的【研报审批】已被驳回" messageItem.ReportApproveId = approveItem.ReportApproveId messageItem.ApproveState = report_approve.ReportApproveStateRefuse messageItem.CreateTime = now messageItem.ModifyTime = now if e := messageItem.Create(); e != nil { utils.FileLog.Info(fmt.Sprintf("ApproveReport message err: %s", e.Error())) return } }() return } // BuildNextNodeRecordAndMsg 生成下一个节点的审批记录并推送消息 func BuildNextNodeRecordAndMsg(approveNodeItem *report_approve.ReportApproveNode, approveId, sysAdminId int, sysAdminName string) (err error) { if approveNodeItem == nil { err = fmt.Errorf("approve node nil") return } // 根据节点审批方式生成审批记录 now := time.Now().Local() approveNode, e := report_approve.FormatReportApproveNode2Item(approveNodeItem) if e != nil { err = fmt.Errorf("FormatReportApproveNode2Item err: %s", e.Error()) return } if len(approveNode.Users) == 0 { err = fmt.Errorf("审批节点用户有误") return } newRecords := make([]*report_approve.ReportApproveRecord, 0) sort.Slice(approveNode.Users, func(k, j int) bool { return approveNode.Users[k].Sort < approveNode.Users[j].Sort }) for _, u := range approveNode.Users { r := new(report_approve.ReportApproveRecord) r.ReportApproveId = approveId r.State = report_approve.ReportApproveStateApproving r.NodeId = approveNode.ReportApproveNodeId r.PrevNodeId = approveNode.PrevNodeId r.NextNodeId = approveNode.NextNodeId r.ApproveType = approveNode.ApproveType r.ApproveUserId = u.UserId r.ApproveUserName = u.UserName r.ApproveUserSort = u.Sort r.CreateTime = now r.ModifyTime = now r.NodeState = report_approve.ReportApproveStateApproving // 当前节点审批状态 newRecords = append(newRecords, r) // 依次审批仅生成一条记录 if approveNode.ApproveType == report_approve.NodeApproveTypeRoll { break } } recordOb := new(report_approve.ReportApproveRecord) if e = recordOb.CreateMulti(newRecords); e != nil { err = fmt.Errorf("生成节点审批记录失败, Err: %s", e.Error()) return } // 推送审批消息 go func() { messageOb := new(report_approve.ReportApproveMessage) messages := make([]*report_approve.ReportApproveMessage, 0) for _, v := range newRecords { m := new(report_approve.ReportApproveMessage) m.SendUserId = sysAdminId m.ReceiveUserId = v.ApproveUserId m.Content = "您有新的待办任务" m.Remark = fmt.Sprintf("%s提交的【研报审批】需要您审批，请及时处理", sysAdminName) m.ReportApproveId = approveId m.ApproveState = report_approve.ReportApproveStateApproving m.CreateTime = now m.ModifyTime = now messages = append(messages, m) } e = messageOb.CreateMulti(messages) if e != nil { utils.FileLog.Info(fmt.Sprintf("BuildNextNodeRecordAndMsg messages err: %s", e.Error())) return } }() return } // AfterReportApprovePass 报告审批通过后的处理 func AfterReportApprovePass(reportType, reportId int) (err error) { // 中文研报 if reportType == report_approve.FlowReportTypeChinese { reportInfo, e := models.GetReportByReportId(reportId) if e != nil { if e.Error() == utils.ErrNoRow() { return } err = fmt.Errorf("获取研报信息失败, Err: %s", e.Error()) return } // 重新生成音频，里面还涉及到章节类型的报告 go UpdateReportVideo(reportInfo) // 生成报告pdf和长图 { reportPdfUrl := GetGeneralPdfUrl(reportInfo.ReportCode, reportInfo.ReportLayout) go Report2pdfAndJpeg(reportPdfUrl, reportId, 1) } //_ = CreateVideo(reportInfo) _ = UpdateReportEs(reportInfo.Id, models.ReportStatePublished) return } // 英文研报 if reportType == report_approve.FlowReportTypeEnglish { _ = UpdateEnglishReportEs(reportId, models.ReportStatePublished) return } // 智能研报 if reportType == report_approve.FlowReportTypeSmart { ob := new(smart_report.SmartReport) item, e := ob.GetItemById(reportId) if e != nil { if e.Error() == utils.ErrNoRow() { return } err = fmt.Errorf("获取智能研报信息失败, Err: %s", e.Error()) return } // 写入队列 //var queue smart_report.Report2ImgQueueReq //queue.ReportType = 2 //queue.ReportCode = item.ReportCode //_ = utils.Rc.LPush(utils.CACHE_CREATE_REPORT_IMGPDF_QUEUE, queue) // 生成音频 if item.VideoUrl == "" { SmartReportBuildVideoAndUpdate(item) } // ES更新报告 _ = SmartReportElasticUpsert(item.SmartReportId, models.ReportStatePublished) } return } // CheckCloseReportApproveConf 校验是否可以关闭报告审批 func CheckCloseReportApproveConf() (yes bool, err error) { // 查询待审批中的报告数量 count, e := models.GetReportStateCount(models.ReportStateWaitApprove) if e != nil { err = fmt.Errorf("查询审批中的报告数量失败, Err: %s", e.Error()) return } if count > 0 { return } count, e = models.GetEnglishReportStateCount(models.ReportStateWaitApprove) if e != nil { err = fmt.Errorf("查询审批中的英文报告数量失败, Err: %s", e.Error()) return } if count > 0 { return } smartOb := new(smart_report.SmartReport) cond := ` AND state = ?` pars := make([]interface{}, 0) pars = append(pars, models.ReportStateWaitApprove) count, e = smartOb.GetCountByCondition(cond, pars) if e != nil { err = fmt.Errorf("查询审批中的智能报告数量失败, Err: %s", e.Error()) return } if count > 0 { return } yes = true return } // FlowOperateResetReportState 审批流变化-重置报告的初始状态 func FlowOperateResetReportState(reportType, classifyFirstId, classifySecondId, classifyThirdId, oldState, State int) (err error) { defer func() { if err != nil { tips := fmt.Sprintf("审批流变化-重置报告初始状态失败, ErrMsg: %s", err.Error()) utils.FileLog.Info(tips) go alarm_msg.SendAlarmMsg(tips, 2) } }() // 中文研报 if reportType == report_approve.FlowReportTypeChinese { e := models.UpdateReportsStateByCond(classifyFirstId, classifySecondId, classifyThirdId, oldState, State) if e != nil { err = fmt.Errorf("UpdateReportsStateByCond err: %s", e.Error()) } return } // 英文研报 if reportType == report_approve.FlowReportTypeEnglish { e := models.UpdateEnglishReportsStateByCond(classifyFirstId, classifySecondId, oldState, State) if e != nil { err = fmt.Errorf("UpdateEnglishReportsStateByCond err: %s", e.Error()) } return } // 智能研报 if reportType == report_approve.FlowReportTypeSmart { e := smart_report.UpdateSmartReportsStateByCond(classifyFirstId, classifySecondId, oldState, State) if e != nil { err = fmt.Errorf("UpdateSmartReportsStateByCond err: %s", e.Error()) } return } return } // ConfigChangeResetReportState 审批配置变化-重置报告的初始状态 func ConfigChangeResetReportState(changeType string) (err error) { defer func() { if err != nil { tips := fmt.Sprintf("审批配置变化-重置报告初始状态失败, ErrMsg: %s", err.Error()) utils.FileLog.Info(tips) go alarm_msg.SendAlarmMsg(tips, 2) } }() // 关闭审批-待提交->未发布 if changeType == "" { e := models.UpdateReportsStateByCond(0, 0, 0, models.ReportStateWaitSubmit, models.ReportStateUnpublished) if e != nil { err = fmt.Errorf("UpdateReportsStateByCond err: %s", e.Error()) } e = models.UpdateEnglishReportsStateByCond(0, 0, models.ReportStateWaitSubmit, models.ReportStateUnpublished) if e != nil { err = fmt.Errorf("UpdateEnglishReportsStateByCond err: %s", e.Error()) } e = smart_report.UpdateSmartReportsStateByCond(0, 0, models.ReportStateWaitSubmit, models.ReportStateUnpublished) if e != nil { err = fmt.Errorf("UpdateSmartReportsStateByCond err: %s", e.Error()) } return } // 开启内部审批-未发布->部分待提交 if changeType == models.BusinessConfReportApproveTypeEta { flowOb := new(report_approve.ReportApproveFlow) flows, e := flowOb.GetItemsByCondition(``, make([]interface{}, 0), []string{}, "") if e != nil { err = fmt.Errorf("GetApproveFlows err: %s", e.Error()) return } reportSecondIds, englishSecondIds, smartSecondIds := make([]int, 0), make([]int, 0), make([]int, 0) for _, v := range flows { if v.ReportType == report_approve.FlowReportTypeChinese { reportSecondIds = append(reportSecondIds, v.ClassifySecondId) continue } if v.ReportType == report_approve.FlowReportTypeEnglish { englishSecondIds = append(englishSecondIds, v.ClassifySecondId) continue } if v.ReportType == report_approve.FlowReportTypeSmart { smartSecondIds = append(smartSecondIds, v.ClassifySecondId) } } if len(reportSecondIds) > 0 { e = models.UpdateReportsStateBySecondIds(models.ReportStateUnpublished, models.ReportStateWaitSubmit, reportSecondIds) if e != nil { err = fmt.Errorf("UpdateReportsStateBySecondIds err: %s", e.Error()) return } } if len(englishSecondIds) > 0 { e = models.UpdateEnglishReportsStateBySecondIds(models.ReportStateUnpublished, models.ReportStateWaitSubmit, englishSecondIds) if e != nil { err = fmt.Errorf("UpdateEnglishReportsStateBySecondIds err: %s", e.Error()) return } } if len(smartSecondIds) > 0 { e = smart_report.UpdateSmartReportsStateBySecondIds(models.ReportStateUnpublished, models.ReportStateWaitSubmit, smartSecondIds) if e != nil { err = fmt.Errorf("UpdateSmartReportsStateBySecondIds err: %s", e.Error()) return } } return } // 开启第三方审批->未发布->待提交 if changeType == models.BusinessConfReportApproveTypeOther { e := models.UpdateReportsStateByCond(0, 0, 0, models.ReportStateUnpublished, models.ReportStateWaitSubmit) if e != nil { err = fmt.Errorf("UpdateReportsStateByCond err: %s", e.Error()) } e = models.UpdateEnglishReportsStateByCond(0, 0, models.ReportStateUnpublished, models.ReportStateWaitSubmit) if e != nil { err = fmt.Errorf("UpdateEnglishReportsStateByCond err: %s", e.Error()) } e = smart_report.UpdateSmartReportsStateByCond(0, 0, models.ReportStateUnpublished, models.ReportStateWaitSubmit) if e != nil { err = fmt.Errorf("UpdateSmartReportsStateByCond err: %s", e.Error()) } return } return }