huangjin/sc-lktx-mp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

'init'

Browse Source
This commit is contained in:
huangjin
2026-06-29 17:34:59 +08:00
commit fe3ad20fe2
271 changed files with 51767 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

787
sc-lktx-backend/internal/modules/workflow/handler.go Normal file
View File

@@ -0,0 +1,787 @@
// 工作流模块 HTTP Handler
package workflow
import (
"encoding/json"
"fmt"
"strconv"
"strings"
"time"
"com.sclktx/m/v2/internal/common/model"
"com.sclktx/m/v2/internal/common/response"
"com.sclktx/m/v2/internal/common/utils"
"com.sclktx/m/v2/internal/pkg/dingtalk"
"com.sclktx/m/v2/internal/pkg/wechat/templates"
"github.com/gin-gonic/gin"
"github.com/sirupsen/logrus"
"gorm.io/gorm"
)
// Handler 工作流处理器
type Handler struct {
db *gorm.DB
engine *Engine
wxSend func(openid, templateID string, data map[string]string, page string) error
dingTalk *dingtalk.Client
}
// NewHandler 创建工作流处理器
func NewHandler(db *gorm.DB, wxSend func(openid, templateID string, data map[string]string, page string) error, dingTalk *dingtalk.Client) *Handler {
return &Handler{
db: db,
engine: NewEngine(db),
wxSend: wxSend,
dingTalk: dingTalk,
}
}
// ==================== 请求/响应结构 ====================
// CreateDefinitionReq 创建流程定义请求
type CreateDefinitionReq struct {
ProcessName string `json:"process_name" binding:"required"`
ProcessCode string `json:"process_code" binding:"required"`
Source string `json:"source"`
Description string `json:"description"`
RevokeEvents string `json:"revoke_events"`
NodesJSON string `json:"nodes_json"`
}
// UpdateDefinitionReq 更新流程定义请求
type UpdateDefinitionReq struct {
ProcessName string `json:"process_name"`
Source string `json:"source"`
Description string `json:"description"`
IsActive *bool `json:"is_active"`
RevokeEvents string `json:"revoke_events"`
NodesJSON string `json:"nodes_json"`
}
// StartInstanceReq 启动流程实例请求
type StartInstanceReq struct {
ProcessCode string `json:"process_code" binding:"required"`
BusinessType string `json:"business_type" binding:"required"`
BusinessID uint `json:"business_id" binding:"required"`
Variables map[string]interface{} `json:"variables"`
}
// TaskActionReq 任务操作请求
type TaskActionReq struct {
Comment string `json:"comment"`
}
// ==================== 路由注册 ====================
// RegisterRoutes 注册工作流路由（需要 JWT 认证）
func (h *Handler) RegisterRoutes(router *gin.RouterGroup) {
// 流程定义（管理员操作）
router.GET("/workflow/definitions", h.ListDefinitions)
router.GET("/workflow/definitions/:id", h.GetDefinition)
router.POST("/workflow/definitions", h.CreateDefinition)
router.PUT("/workflow/definitions/:id", h.UpdateDefinition)
router.DELETE("/workflow/definitions/:id", h.DeleteDefinition)
// 流程实例
router.POST("/workflow/instances", h.StartInstance)
router.GET("/workflow/instances", h.ListInstances)
router.GET("/workflow/instances/:id", h.GetInstanceDetail)
// 任务
router.GET("/workflow/tasks/pending", h.GetPendingTasks)
router.POST("/workflow/tasks/:id/approve", h.ApproveTask)
router.POST("/workflow/tasks/:id/reject", h.RejectTask)
}
// ==================== 流程定义管理 ====================
// ListDefinitions 获取流程定义列表
// @Summary 获取流程定义列表
// @Description 获取所有流程定义列表
// @Tags 工作流
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param page query int false "页码" default(1)
// @Param page_size query int false "每页条数" default(10)
// @Success 200 {object} response.Response "success"
// @Router /api/v1/workflow/definitions [get]
func (h *Handler) ListDefinitions(c *gin.Context) {
page, pageSize := utils.ParsePagination(c)
var defs []model.ProcessDefinition
var total int64
query := h.db.Model(&model.ProcessDefinition{})
query.Count(&total)
query.Offset(utils.GetOffset(page, pageSize)).
Limit(pageSize).
Order("created_at DESC").
Find(&defs)
response.SuccessPage(c, defs, total, page, pageSize)
}
// GetDefinition 获取流程定义详情
// @Summary 获取流程定义详情
// @Description 根据ID获取流程定义详情
// @Tags 工作流
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param id path uint true "流程定义ID"
// @Success 200 {object} response.Response "success"
// @Router /api/v1/workflow/definitions/{id} [get]
func (h *Handler) GetDefinition(c *gin.Context) {
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
if err != nil {
response.BadRequest(c, "参数错误")
return
}
var def model.ProcessDefinition
if err := h.db.First(&def, id).Error; err != nil {
response.NotFound(c, "流程定义不存在")
return
}
response.Success(c, def)
}
// CreateDefinition 创建流程定义
// @Summary 创建流程定义
// @Description 创建一个新的流程定义（管理员操作）
// @Tags 工作流
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param body body CreateDefinitionReq true "创建流程定义请求"
// @Success 200 {object} response.Response "success"
// @Router /api/v1/workflow/definitions [post]
func (h *Handler) CreateDefinition(c *gin.Context) {
var req CreateDefinitionReq
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, "参数错误")
return
}
// 检查编码唯一性
var existCount int64
h.db.Model(&model.ProcessDefinition{}).Where("process_code = ?", req.ProcessCode).Count(&existCount)
if existCount > 0 {
response.BadRequest(c, "流程编码已存在")
return
}
def := model.ProcessDefinition{
ProcessName: req.ProcessName,
ProcessCode: req.ProcessCode,
Source: req.Source,
Description: req.Description,
IsActive: true,
RevokeEvents: req.RevokeEvents,
NodesJSON: req.NodesJSON,
}
if err := h.db.Create(&def).Error; err != nil {
response.InternalError(c, "创建失败")
return
}
response.SuccessWithMessage(c, "创建成功", def)
}
// UpdateDefinition 更新流程定义
// @Summary 更新流程定义
// @Description 更新指定流程定义的信息（管理员操作）
// @Tags 工作流
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param id path uint true "流程定义ID"
// @Param body body UpdateDefinitionReq true "更新流程定义请求"
// @Success 200 {object} response.Response "success"
// @Router /api/v1/workflow/definitions/{id} [put]
func (h *Handler) UpdateDefinition(c *gin.Context) {
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
if err != nil {
response.BadRequest(c, "参数错误")
return
}
var def model.ProcessDefinition
if err := h.db.First(&def, id).Error; err != nil {
response.NotFound(c, "流程定义不存在")
return
}
var req UpdateDefinitionReq
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, "参数错误")
return
}
updates := map[string]interface{}{}
if req.ProcessName != "" {
updates["process_name"] = req.ProcessName
}
if req.Source != "" {
updates["source"] = req.Source
}
if req.Description != "" {
updates["description"] = req.Description
}
if req.IsActive != nil {
updates["is_active"] = *req.IsActive
}
if req.RevokeEvents != "" {
updates["revoke_events"] = req.RevokeEvents
}
if req.NodesJSON != "" {
updates["nodes_json"] = req.NodesJSON
}
if len(updates) > 0 {
if err := h.db.Model(&def).Updates(updates).Error; err != nil {
response.InternalError(c, "更新失败")
return
}
}
response.SuccessWithMessage(c, "更新成功", nil)
}
// DeleteDefinition 删除流程定义
// @Summary 删除流程定义
// @Description 删除指定的流程定义（管理员操作，存在运行中的实例时无法删除）
// @Tags 工作流
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param id path uint true "流程定义ID"
// @Success 200 {object} response.Response "success"
// @Router /api/v1/workflow/definitions/{id} [delete]
func (h *Handler) DeleteDefinition(c *gin.Context) {
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
if err != nil {
response.BadRequest(c, "参数错误")
return
}
// 检查是否有运行中的实例
var activeCount int64
h.db.Model(&model.ProcessInstance{}).Where("process_def_id = ? AND status = 0", id).Count(&activeCount)
if activeCount > 0 {
response.BadRequest(c, "存在运行中的流程实例，无法删除")
return
}
if err := h.db.Delete(&model.ProcessDefinition{}, id).Error; err != nil {
response.InternalError(c, "删除失败")
return
}
response.SuccessWithMessage(c, "删除成功", nil)
}
// ==================== 流程实例管理 ====================
// StartInstance 启动流程实例
// @Summary 启动流程实例
// @Description 根据流程定义启动一个新的流程实例
// @Tags 工作流
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param body body StartInstanceReq true "启动流程实例请求"
// @Success 200 {object} response.Response "success"
// @Router /api/v1/workflow/instances [post]
func (h *Handler) StartInstance(c *gin.Context) {
var req StartInstanceReq
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, "参数错误")
return
}
// 查找流程定义
var def model.ProcessDefinition
if err := h.db.Where("process_code = ?", req.ProcessCode).First(&def).Error; err != nil {
response.NotFound(c, "流程定义不存在")
return
}
userID := utils.GetUserID(c)
instance, err := h.engine.StartInstance(def.ID, req.BusinessType, req.BusinessID, userID, req.Variables)
if err != nil {
response.InternalError(c, err.Error())
return
}
response.SuccessWithMessage(c, "启动成功", instance)
}
// ListInstances 获取流程实例列表
// @Summary 获取流程实例列表
// @Description 获取所有流程实例列表，可按业务类型和状态筛选
// @Tags 工作流
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param business_type query string false "业务类型"
// @Param status query int false "实例状态"
// @Param page query int false "页码" default(1)
// @Param page_size query int false "每页条数" default(10)
// @Success 200 {object} response.Response "success"
// @Router /api/v1/workflow/instances [get]
func (h *Handler) ListInstances(c *gin.Context) {
page, pageSize := utils.ParsePagination(c)
businessType := c.Query("business_type")
businessIDStr := c.Query("business_id")
statusStr := c.Query("status")
var instances []model.ProcessInstance
var total int64
query := h.db.Model(&model.ProcessInstance{}).
Preload("ProcessDef").
Preload("Starter")
if businessType != "" {
query = query.Where("business_type = ?", businessType)
}
if businessIDStr != "" {
businessID, _ := strconv.ParseUint(businessIDStr, 10, 64)
if businessID > 0 {
query = query.Where("business_id = ?", businessID)
}
}
if statusStr != "" {
status, _ := strconv.Atoi(statusStr)
query = query.Where("status = ?", status)
}
query.Count(&total)
query.Offset(utils.GetOffset(page, pageSize)).
Limit(pageSize).
Order("created_at DESC").
Find(&instances)
response.SuccessPage(c, instances, total, page, pageSize)
}
// GetInstanceDetail 获取流程实例详情（含任务列表）
// @Summary 获取流程实例详情
// @Description 获取流程实例详情，包含关联的任务列表
// @Tags 工作流
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param id path uint true "流程实例ID"
// @Success 200 {object} response.Response "success"
// @Router /api/v1/workflow/instances/{id} [get]
func (h *Handler) GetInstanceDetail(c *gin.Context) {
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
if err != nil {
response.BadRequest(c, "参数错误")
return
}
var instance model.ProcessInstance
if err := h.db.Preload("ProcessDef").Preload("Starter").First(&instance, id).Error; err != nil {
response.NotFound(c, "流程实例不存在")
return
}
var tasks []model.Task
h.db.Where("instance_id = ?", id).
Preload("Assignee").
Order("created_at ASC").
Find(&tasks)
response.Success(c, gin.H{
"instance": instance,
"tasks": tasks,
})
}
// ==================== 任务管理 ====================
// GetPendingTasks 获取当前用户的待办任务
// @Summary 获取待办任务
// @Description 获取当前用户的待处理流程任务列表
// @Tags 工作流
// @Accept json
// @Produce json
// @Security BearerAuth
// @Success 200 {object} response.Response "success"
// @Router /api/v1/workflow/tasks/pending [get]
func (h *Handler) GetPendingTasks(c *gin.Context) {
userID := utils.GetUserID(c)
var tasks []model.Task
h.db.Where("assignee_id = ? AND status = 0", userID).
Preload("Instance").
Preload("Instance.ProcessDef").
Preload("Assignee").
Order("created_at DESC").
Find(&tasks)
response.Success(c, tasks)
}
// ApproveTask 审批通过任务
// @Summary 审批通过任务
// @Description 审批通过指定的流程任务
// @Tags 工作流
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param id path uint true "任务ID"
// @Param body body TaskActionReq true "审批请求"
// @Success 200 {object} response.Response "success"
// @Router /api/v1/workflow/tasks/{id}/approve [post]
func (h *Handler) ApproveTask(c *gin.Context) {
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
if err != nil {
response.BadRequest(c, "参数错误")
return
}
var req TaskActionReq
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, "参数错误")
return
}
userID := utils.GetUserID(c)
if err := h.engine.ApproveTask(uint(id), userID, req.Comment); err != nil {
response.InternalError(c, err.Error())
return
}
// 审批完成后发送通知
h.sendAppointmentNotification(uint(id))
h.sendDingTalkAfterApproval(uint(id), req.Comment)
response.SuccessWithMessage(c, "审批通过", nil)
}
// RejectTask 审批拒绝任务
// @Summary 审批拒绝任务
// @Description 拒绝指定的流程任务
// @Tags 工作流
// @Accept json
// @Produce json
// @Security BearerAuth
// @Param id path uint true "任务ID"
// @Param body body TaskActionReq true "拒绝请求"
// @Success 200 {object} response.Response "success"
// @Router /api/v1/workflow/tasks/{id}/reject [post]
func (h *Handler) RejectTask(c *gin.Context) {
id, err := strconv.ParseUint(c.Param("id"), 10, 64)
if err != nil {
response.BadRequest(c, "参数错误")
return
}
var req TaskActionReq
if err := c.ShouldBindJSON(&req); err != nil {
response.BadRequest(c, "参数错误")
return
}
userID := utils.GetUserID(c)
if err := h.engine.RejectTask(uint(id), userID, req.Comment); err != nil {
response.InternalError(c, err.Error())
return
}
// 拒绝后发送通知
h.sendAppointmentNotification(uint(id))
h.sendDingTalkAfterRejection(uint(id), req.Comment)
response.SuccessWithMessage(c, "已拒绝", nil)
}
// sendAppointmentNotification 审批结束后发送微信通知给申请人
func (h *Handler) sendAppointmentNotification(taskID uint) {
var task model.Task
if err := h.db.Preload("Instance").First(&task, taskID).Error; err != nil {
return
}
if task.Instance == nil || task.Instance.BusinessType != "appointment" {
return
}
go func() {
var appointment model.Appointment
if err := h.db.First(&appointment, task.Instance.BusinessID).Error; err != nil {
return
}
// 只发送已通过或已拒绝的通知
if appointment.Status != 1 && appointment.Status != 2 {
return
}
var creatorUser model.User
if err := h.db.First(&creatorUser, appointment.CreatorUserID).Error; err != nil || creatorUser.Openid == "" {
return
}
resultText := "已通过"
if appointment.Status == 2 {
resultText = "已拒绝"
}
// 解析 JSON 字段
var employeeInfo map[string]interface{}
json.Unmarshal([]byte(appointment.EmployeeInfo), &employeeInfo)
var visitorInfo map[string]interface{}
json.Unmarshal([]byte(appointment.VisitorInfo), &visitorInfo)
company, _ := visitorInfo["company"].(string)
employeeName, _ := employeeInfo["name"].(string)
var areasInfo []string
json.Unmarshal([]byte(appointment.AreasInfo), &areasInfo)
areaText := strings.Join(areasInfo, "、")
// 格式化时间（微信 thing 类型字段限 20 字）
timeStr := ""
if !appointment.VisitStartTime.IsZero() {
loc, _ := time.LoadLocation("Asia/Shanghai")
timeStr = appointment.VisitStartTime.In(loc).Format("01-02 15:04") + "-" + appointment.VisitEndTime.In(loc).Format("15:04")
}
// TMPL_RESULT: 访客申请结果通知（thing 字段限 20 字）
trunc := func(s string) string {
runes := []rune(s)
if len(runes) > 20 {
return string(runes[:20])
}
return s
}
tmplID := templates.TMPL_RESULT
if h.wxSend != nil {
h.wxSend(creatorUser.Openid, tmplID, map[string]string{
"thing1": trunc(resultText),
"thing2": trunc(company),
"thing3": trunc(timeStr),
"thing8": trunc(employeeName),
"thing9": trunc(areaText),
}, fmt.Sprintf("/subpackages/appointment/appointment-detail?id=%d", appointment.ID))
}
}()
}
// sendDingTalkAfterApproval 审批通过后发送钉钉消息
func (h *Handler) sendDingTalkAfterApproval(taskID uint, comment string) {
if h.dingTalk == nil {
return
}
var task model.Task
if err := h.db.Preload("Instance").First(&task, taskID).Error; err != nil {
return
}
if task.Instance == nil || task.Instance.BusinessType != "appointment" || task.Instance.Status != 0 {
return
}
logrus.WithFields(logrus.Fields{
"task_id": taskID,
"instance_id": task.InstanceID,
}).Info("钉钉：审批通过，开始发送通知")
go func() {
// 获取审批人信息
var approverUser model.User
if task.AssigneeID == nil {
return
}
if err := h.db.First(&approverUser, *task.AssigneeID).Error; err != nil {
logrus.WithError(err).WithField("task_id", taskID).Warn("钉钉：查询审批人信息失败")
return
}
// 获取预约信息
var appointment model.Appointment
if err := h.db.First(&appointment, task.Instance.BusinessID).Error; err != nil {
return
}
var visitorInfo struct {
Name string `json:"name"`
Company string `json:"company"`
}
json.Unmarshal([]byte(appointment.VisitorInfo), &visitorInfo)
visitTime := ""
if !appointment.VisitStartTime.IsZero() {
visitTime = dingtalk.FormatCSTTime(appointment.VisitStartTime, appointment.VisitEndTime)
}
// 1. 通知被取消的同节点审批人（同一节点非会签模式，其他人审批后当前节点其他人被取消）
var cancelledTasks []model.Task
if err := h.db.Where("instance_id = ? AND node_id = ? AND status = 3 AND id != ?",
task.InstanceID, task.NodeID, task.ID).Find(&cancelledTasks).Error; err == nil && len(cancelledTasks) > 0 {
var userIDs []string
for _, ct := range cancelledTasks {
if ct.AssigneeID != nil {
var ud model.UserDepartment
if err := h.db.Where("user_id = ?", *ct.AssigneeID).First(&ud).Error; err == nil && ud.DingTalkUserID != "" {
userIDs = append(userIDs, ud.DingTalkUserID)
} else if err != nil {
logrus.WithError(err).WithField("user_id", *ct.AssigneeID).Warn("钉钉：查询同节点取消人 UserDepartment 失败")
} else {
logrus.WithField("user_id", *ct.AssigneeID).Warn("钉钉：同节点取消人 DingTalkUserID 为空")
}
}
}
if len(userIDs) > 0 {
title, markdown := dingtalk.BuildSameNodeCancelledMsg(approverUser.RealName, comment, visitTime)
logrus.WithFields(logrus.Fields{
"user_ids": userIDs,
"title": title,
}).Info("钉钉：发送同节点取消通知")
if err := h.dingTalk.BatchSendRobotMessage(userIDs, title, markdown); err != nil {
logrus.WithError(err).Error("钉钉发送同节点取消通知失败")
}
} else {
logrus.WithField("cancelled_count", len(cancelledTasks)).Info("钉钉：同节点已取消任务无有效钉钉ID")
}
} else {
logrus.WithField("has_cancelled", len(cancelledTasks) > 0).Info("钉钉：无同节点取消任务")
}
// 2. 通知下一个节点审批人
var pendingTasks []model.Task
if err := h.db.Where("instance_id = ? AND status = 0", task.InstanceID).Find(&pendingTasks).Error; err == nil && len(pendingTasks) > 0 {
var userIDs []string
for _, pt := range pendingTasks {
if pt.AssigneeID != nil {
var ud model.UserDepartment
if err := h.db.Where("user_id = ?", *pt.AssigneeID).First(&ud).Error; err == nil && ud.DingTalkUserID != "" {
userIDs = append(userIDs, ud.DingTalkUserID)
} else if err != nil {
logrus.WithError(err).WithField("user_id", *pt.AssigneeID).Warn("钉钉：查询下一节点审批人 UserDepartment 失败")
} else {
logrus.WithField("user_id", *pt.AssigneeID).Warn("钉钉：下一节点审批人 DingTalkUserID 为空")
}
}
}
if len(userIDs) > 0 {
msg := &dingtalk.AppointmentResultMessage{
ApproverName: approverUser.RealName,
Action: "通过",
Comment: comment,
AppointmentID: appointment.ID,
VisitTime: visitTime,
VisitorName: visitorInfo.Name,
}
title, markdown := dingtalk.BuildApproveNotificationMsg(msg)
logrus.WithFields(logrus.Fields{
"user_ids": userIDs,
"title": title,
}).Info("钉钉：发送下一节点审批人通知")
if err := h.dingTalk.BatchSendRobotMessage(userIDs, title, markdown); err != nil {
logrus.WithError(err).Error("钉钉发送下一节点通知失败")
}
} else {
logrus.WithField("pending_count", len(pendingTasks)).Info("钉钉：下一节点无有效钉钉ID的审批人")
}
} else {
logrus.WithField("has_pending", len(pendingTasks) > 0).Info("钉钉：无下一节点待审批任务")
}
}()
}
// sendDingTalkAfterRejection 审批拒绝后发送钉钉消息
func (h *Handler) sendDingTalkAfterRejection(taskID uint, comment string) {
if h.dingTalk == nil {
return
}
var task model.Task
if err := h.db.Preload("Instance").First(&task, taskID).Error; err != nil {
return
}
if task.Instance == nil || task.Instance.BusinessType != "appointment" {
return
}
logrus.WithFields(logrus.Fields{
"task_id": taskID,
"instance_id": task.InstanceID,
}).Info("钉钉：审批拒绝，开始发送通知")
go func() {
// 获取拒绝人信息
var rejector model.User
if task.AssigneeID == nil {
return
}
if err := h.db.First(&rejector, *task.AssigneeID).Error; err != nil {
logrus.WithError(err).WithField("task_id", taskID).Warn("钉钉：查询拒绝人信息失败")
return
}
// 获取预约信息
var appointment model.Appointment
if err := h.db.First(&appointment, task.Instance.BusinessID).Error; err != nil {
return
}
var visitorInfo struct {
Name string `json:"name"`
Company string `json:"company"`
}
json.Unmarshal([]byte(appointment.VisitorInfo), &visitorInfo)
visitTime := ""
if !appointment.VisitStartTime.IsZero() {
visitTime = dingtalk.FormatCSTTime(appointment.VisitStartTime, appointment.VisitEndTime)
}
// 查找本实例中其他待审批任务，通知其审批人流程已终止
var otherPendingTasks []model.Task
if err := h.db.Where("instance_id = ? AND status = 0 AND id != ?", task.InstanceID, task.ID).Find(&otherPendingTasks).Error; err != nil {
return
}
var userIDs []string
for _, pt := range otherPendingTasks {
if pt.AssigneeID != nil {
var ud model.UserDepartment
if err := h.db.Where("user_id = ?", *pt.AssigneeID).First(&ud).Error; err == nil && ud.DingTalkUserID != "" {
userIDs = append(userIDs, ud.DingTalkUserID)
} else if err != nil {
logrus.WithError(err).WithField("user_id", *pt.AssigneeID).Warn("钉钉：查询其他待审批人 UserDepartment 失败")
} else {
logrus.WithField("user_id", *pt.AssigneeID).Warn("钉钉：其他待审批人 DingTalkUserID 为空")
}
}
}
if len(userIDs) > 0 {
msg := &dingtalk.AppointmentResultMessage{
ApproverName: rejector.RealName,
Action: "拒绝",
Comment: comment,
AppointmentID: appointment.ID,
VisitTime: visitTime,
VisitorName: visitorInfo.Name,
}
title, markdown := dingtalk.BuildRejectNotificationMsg(msg)
logrus.WithFields(logrus.Fields{
"user_ids": userIDs,
"title": title,
}).Info("钉钉：发送拒绝通知给其他待审批人")
if err := h.dingTalk.BatchSendRobotMessage(userIDs, title, markdown); err != nil {
logrus.WithError(err).Error("钉钉发送拒绝通知失败")
}
} else {
logrus.WithField("other_pending_count", len(otherPendingTasks)).Info("钉钉：拒绝后无其他待审批人需通知")
}
}()
}