简单聊聊

在我们平时的工作中，会有很多时候需要跟其他同事进行协同办公，甚至需要跨部门合作，在这种情况下，我们就需要同事之间的沟通交流，而沟通过程中一句不合适的话，都会造成争吵，跨部门合作的时候，更加麻烦，因为对彼此都不熟悉，因此很难进行很好的沟通交流。

其实很多时候，我们的工作都是流程化，上一位同事处理完，下一位同事接着进行处理，在这种场景需求下就诞生了工单系统，将一个任务处理过程中，所涉及到的人，按照优先级排列，然后依次进行处理，处理过程中可进行注解，方便下一个处理人对之前处理结果的熟悉，并且处理完成后通过邮件或者其他通讯方式通知下一个人处理，依次类推，当处理完成后，通知工单申请人，工单已全部处理完成。

其实目前有一些现成的工单系统了，有开源的也有收费的，但是普遍的功能比较单一，不方便管理，当然肯定有我不知道的非常流弊的工单系统，只是在说我已知的，如果冒犯到你的话，深感抱歉。

本篇文章就给大家详细的介绍一下如何设计一个灵活，易维护管理的工单系统，在介绍此工单系统之前，首先给大家推荐一个还是不错的工单系统，供大家参考，学习。

Demo: ferry 工单系统(点击进入演示Demo)

Github: https://github.com/lanyulei/ferry

Gitee: https://gitee.com/yllan/ferry

核心功能介绍

单点登陆

目前大部分公司都会安装部署一套单点登录系统，方便维护管理员工的账号信息，同时实现多系统的用户登陆，例如Ldap，因此支持主流的单点登录系统也是很有必要的。

权限管理

对于一个工单系统来说，因为涉及的人会非常多，审批阶段会有各层次的领导进行审阅；处理阶段会有各部门的人进行处理。因此对于权限的管理是要非常的严格。

流程设计

在工单系统中流程设计应该算是最繁琐的地方了，要定义好每个节点的关联关系、处理人以及各种属性数据，如果没有一个好的流程设计工具，对于工单系统的用户体验来说，是非常差的。而且对于后续的维护也是非常的不易。

之前就有朋友说，他们的工单系统是写死的，每个流程，每个节点，每个处理人都是在代码里定义好的，这样的工单系统是非常不易用的，只要有人员变动，流程变动，都需要重新修改代码进行编译上线，因此好的流程设计工具，对一个好的工单系统来说，是至关重要的。

模版设计

我们在提交工单的时候，需要写很多的描述数据，例如申请服务器，就需要写服务器的配置信息，像是CPU、内存、磁盘等信息，这些需要写的描述数据，并非是一成不变的，会根据场景的不同而进行适当的修改，因此我们就需要有一个可视化的表单设计工具，来进行表单模版的维护管理，通过将表单模版与流程的关联从而实现一条完整的工作流。

多样化的工单列表

我们工单系统内的工单，根据工单归属的分类，可以大概的分为：我创建的工单、我待办的工单、我相关的工单以及所有工单。我们根据这4类工单归属类型进行数据的分类展示，方便他人的使用及查看。

任务管理

在一个工单流程中，通常很多操作都是可以自动完成的，比如申请数据库账号，可以让用户填写好数据后，DBA审批通过，则自动去创建账号，并进行邮件或者其他通讯工具进行通知。这种就能节省很多人为操作，使这个人可以处理更多其他的工作。毕竟20世纪最贵的成本是人力呢。

更多其他功能点

• 加签： 临时将工单转交给他人处理，处理完成后自动返回给原来的处理人。
• 会签： 当一个节点出现多个处理人的时候，则需要所有的处理人都处理完成才可进行下一步。
• 催办： 催促当前节点的处理人尽快处理，当然需要设置时间间隔的。
• 结单： 有的时候我们会提错单子，因为可联系管理员进行手动结单。
• 转交： 在流程中，某一节点的处理人临时有时间，商议后，可转交给他人。
• 主动接单： 当一个节点出现多个处理人的时候，配置主动接单后，需这几个人进行抢单处理。
• 等等，还有很多扩展的功能，有兴趣的人，可以加群一起聊聊：1127401830 。

以上就是大概总结的一些核心的功能，当然还有很多细小的划分。更精细的设计就需要大家去认真构思了。毕竟一篇文章如果说考虑到方方面面的话，那是不现实的，得需要码多少字呢。

数据库设计

其实开发一个系统，最耗费时间的不是敲代码的部分。程序设计，数据结构设计才是最繁琐的，要考虑到各种场景、各种关联。

所以这里就不藏私了，直接给大家看下我的数据结构设计：

用户/权限/菜单/系统配置

工单系统

核心功能代码

在此将核心功能中代码给大家展示一下，但是肯定不会全部的（因为实在是太多了，贴不完呢），有兴趣的可以去Github上Clone下来详细的研究一下。

Github: https://github.com/lanyulei/ferry

Gitee: https://gitee.com/yllan/ferry

Ldap登陆验证

ldap算是比较常用的一个单点登陆系统了，跟同事、同学、朋友聊天的过程中，能感觉大部分都是在使用ldap。当然有人会说ldap是一个协议，这些就不用纠结这些细节了，你也可以说，使用了ldap协议单点登录系统。

集成ldap登陆验证后，在用户验证通过会，会将数据保存至本地数据库一份，方便维护管理。

连接ldap：

package ldap

import (
    "crypto/tls"
    "errors"
    "ferry/pkg/logger"
    "fmt"
    "time"

    "github.com/spf13/viper"

    "github.com/go-ldap/ldap/v3"
)

/*
  @Author : lanyulei
*/

var conn *ldap.Conn

// ldap连接
func ldapConnection() (err error) {
    var ldapConn = fmt.Sprintf("%v:%v", viper.GetString("settings.ldap.host"), viper.GetString("settings.ldap.port"))

    conn, err = ldap.Dial(
        "tcp",
        ldapConn,
    )
    if err != nil {
        err = errors.New(fmt.Sprintf("无法连接到ldap服务器，%v", err))
        logger.Error(err)
        return
    }

    if viper.GetBool("settings.ldap.tls") {
        err = conn.StartTLS(&tls.Config{
            InsecureSkipVerify: true,
        })
        if err != nil {
            err = errors.New(fmt.Sprintf("升级到加密方式失败，%v", err))
            logger.Error(err)
            return
        }
    }

    //设置超时时间
    conn.SetTimeout(5 * time.Second)

    return
}

搜索ldap用户信息：

package ldap

import (
    "encoding/json"
    "errors"
    "ferry/global/orm"
    "ferry/models/system"
    "ferry/pkg/logger"
    "fmt"

    "github.com/go-ldap/ldap/v3"
    "github.com/spf13/viper"
)

/*
  @Author : lanyulei
*/

func getLdapFields() (ldapFields []map[string]string, err error) {
    var (
        settingsValue system.Settings
        contentList   []map[string]string
    )

    err = orm.Eloquent.Model(&settingsValue).Where("classify = 2").Find(&settingsValue).Error
    if err != nil {
        return
    }

    err = json.Unmarshal(settingsValue.Content, &contentList)
    if err != nil {
        return
    }

    for _, v := range contentList {
        if v["ldap_field_name"] != "" {
            ldapFields = append(ldapFields, v)
        }
    }
    return
}

func searchRequest(username string) (userInfo *ldap.Entry, err error) {
    var (
        ldapFields       []map[string]string
        cur              *ldap.SearchResult
        ldapFieldsFilter = []string{
            "dn",
        }
    )
    ldapFields, err = getLdapFields()
    for _, v := range ldapFields {
        ldapFieldsFilter = append(ldapFieldsFilter, v["ldap_field_name"])
    }
    // 用来获取查询权限的用户。如果 ldap 禁止了匿名查询，那我们就需要先用这个帐户 bind 以下才能开始查询
    if !viper.GetBool("settings.ldap.anonymousQuery") {
        err = conn.Bind(
            fmt.Sprintf("cn=%v,%v",
                viper.GetString("settings.ldap.bindUser"),
                viper.GetString("settings.ldap.baseDn")),
            viper.GetString("settings.ldap.bindPwd"))
        if err != nil {
            logger.Error("用户或密码错误。", err)
            return
        }
    }

    sql := ldap.NewSearchRequest(
        viper.GetString("settings.ldap.baseDn"),
        ldap.ScopeWholeSubtree,
        ldap.DerefAlways,
        0,
        0,
        false,
        fmt.Sprintf("(cn=%s)", username),
        ldapFieldsFilter,
        nil)

    if cur, err = conn.Search(sql); err != nil {
        err = errors.New(fmt.Sprintf("在Ldap搜索用户失败, %v", err))
        logger.Error(err)
        return
    }

    if len(cur.Entries) == 0 {
        err = errors.New("未查询到对应的用户信息。")
        logger.Error(err)
        return
    }

    userInfo = cur.Entries[0]

    return
}

映射本地数据库字段：

package ldap

import (
    "ferry/models/system"

    "github.com/go-ldap/ldap/v3"
)

/*
  @Author : lanyulei
*/

func LdapFieldsMap(ldapUserInfo *ldap.Entry) (userInfo system.SysUser, err error) {
    var (
        ldapFields []map[string]string
    )

    ldapFields, err = getLdapFields()
    if err != nil {
        return
    }

    for _, v := range ldapFields {
        switch v["local_field_name"] {
        case "nick_name":
            userInfo.NickName = ldapUserInfo.GetAttributeValue(v["ldap_field_name"])
        case "phone":
            userInfo.Phone = ldapUserInfo.GetAttributeValue(v["ldap_field_name"])
        case "avatar":
            userInfo.Avatar = ldapUserInfo.GetAttributeValue(v["ldap_field_name"])
        case "sex":
            userInfo.Sex = ldapUserInfo.GetAttributeValue(v["ldap_field_name"])
        case "email":
            userInfo.Email = ldapUserInfo.GetAttributeValue(v["ldap_field_name"])
        case "remark":
            userInfo.Remark = ldapUserInfo.GetAttributeValue(v["ldap_field_name"])
        }
    }

    return
}

ldap用户登陆：

package ldap

import (
    "fmt"

    "github.com/go-ldap/ldap/v3"
)

/*
  @Author : lanyulei
*/

func LdapLogin(username string, password string) (userInfo *ldap.Entry, err error) {
    err = ldapConnection()
    if err != nil {
        return
    }
    defer conn.Close()

    userInfo, err = searchRequest(username)
    if err != nil {
        return
    }

    err = conn.Bind(userInfo.DN, password)
    if err != nil {
        return nil, fmt.Errorf("用户或密码不正确。")
    }

    return
}

工单流转

在一个工单系统中，最核心的部分就是工单流转，要兼容各种处理人信息，并且根据节点之间的关联进行节点的流转，因此，在工单流转这一部分我们需要非常认真对待，因为如果你不认真对待，可能会造成工单流转到一个非此流程相关的人名下，对于用户体验是非常差的，甚至会丧失用户对系统的信用不再使用此系统。所以这段是重中之重。需认真对待。

package service

import (
    "encoding/json"
    "errors"
    "ferry/global/orm"
    "ferry/models/base"
    "ferry/models/process"
    "ferry/models/system"
    "ferry/pkg/notify"
    "ferry/tools"
    "fmt"
    "reflect"
    "time"

    "github.com/jinzhu/gorm"

    "github.com/gin-gonic/gin"
)

/*
  @Author : lanyulei
  @Desc : 处理工单
*/

/*
    -- 节点 --
    start: 开始节点
    userTask: 审批节点
    receiveTask: 处理节点
    scriptTask: 任务节点
    end: 结束节点
    -- 网关 --
    exclusiveGateway: 排他网关
    parallelGateway: 并行网关
    inclusiveGateway: 包容网关
*/

type Handle struct {
    cirHistoryList   []process.CirculationHistory
    workOrderId      int
    updateValue      map[string]interface{}
    stateValue       map[string]interface{}
    targetStateValue map[string]interface{}
    workOrderData    [][]byte
    workOrderDetails process.WorkOrderInfo
    endHistory       bool
    flowProperties   int
    circulationValue string
    processState     ProcessState
    tx               *gorm.DB
}

// 时间格式化
func fmtDuration(d time.Duration) string {
    d = d.Round(time.Minute)
    h := d / time.Hour
    d -= h * time.Hour
    m := d / time.Minute
    return fmt.Sprintf("%02d小时 %02d分钟", h, m)
}

// 会签
func (h *Handle) Countersign(c *gin.Context) (err error) {
    var (
        stateList       []map[string]interface{}
        stateIdMap      map[string]interface{}
        currentState    map[string]interface{}
        cirHistoryCount int
    )

    err = json.Unmarshal(h.workOrderDetails.State, &stateList)
    if err != nil {
        return
    }

    stateIdMap = make(map[string]interface{})
    for _, v := range stateList {
        stateIdMap[v["id"].(string)] = v["label"]
        if v["id"].(string) == h.stateValue["id"].(string) {
            currentState = v
        }
    }
    for _, cirHistoryValue := range h.cirHistoryList {
        if _, ok := stateIdMap[cirHistoryValue.Source]; !ok {
            break
        }
        for _, processor := range currentState["processor"].([]interface{}) {
            if cirHistoryValue.ProcessorId != tools.GetUserId(c) &&
                cirHistoryValue.Source == currentState["id"].(string) &&
                cirHistoryValue.ProcessorId == int(processor.(float64)) {
                cirHistoryCount += 1
            }
        }
    }
    if cirHistoryCount == len(currentState["processor"].([]interface{}))-1 {
        h.endHistory = true
        err = h.circulation()
        if err != nil {
            return
        }
    }
    return
}

// 工单跳转
func (h *Handle) circulation() (err error) {
    var (
        stateValue []byte
    )

    stateList := make([]interface{}, 0)
    for _, v := range h.updateValue["state"].([]map[string]interface{}) {
        stateList = append(stateList, v)
    }
    err = GetVariableValue(stateList, h.workOrderDetails.Creator)
    if err != nil {
        return
    }

    stateValue, err = json.Marshal(h.updateValue["state"])
    if err != nil {
        return
    }

    err = h.tx.Model(&process.WorkOrderInfo{}).
        Where("id = ?", h.workOrderId).
        Updates(map[string]interface{}{
            "state":          stateValue,
            "related_person": h.updateValue["related_person"],
        }).Error
    if err != nil {
        h.tx.Rollback()
        return
    }
    return
}

// 条件判断
func (h *Handle) ConditionalJudgment(condExpr map[string]interface{}) (result bool, err error) {
    var (
        condExprOk    bool
        condExprValue interface{}
    )

    defer func() {
        if r := recover(); r != nil {
            switch e := r.(type) {
            case string:
                err = errors.New(e)
            case error:
                err = e
            default:
                err = errors.New("未知错误")
            }
            return
        }
    }()

    for _, data := range h.workOrderData {
        var formData map[string]interface{}
        err = json.Unmarshal(data, &formData)
        if err != nil {
            return
        }
        if condExprValue, condExprOk = formData[condExpr["key"].(string)]; condExprOk {
            break
        }
    }

    if condExprValue == nil {
        err = errors.New("未查询到对应的表单数据。")
        return
    }

    // todo 待优化
    switch reflect.TypeOf(condExprValue).String() {
    case "string":
        switch condExpr["sign"] {
        case "==":
            if condExprValue.(string) == condExpr["value"].(string) {
                result = true
            }
        case "!=":
            if condExprValue.(string) != condExpr["value"].(string) {
                result = true
            }
        case ">":
            if condExprValue.(string) > condExpr["value"].(string) {
                result = true
            }
        case ">=":
            if condExprValue.(string) >= condExpr["value"].(string) {
                result = true
            }
        case "<":
            if condExprValue.(string) < condExpr["value"].(string) {
                result = true
            }
        case "<=":
            if condExprValue.(string) <= condExpr["value"].(string) {
                result = true
            }
        default:
            err = errors.New("目前仅支持6种常规判断类型，包括（等于、不等于、大于、大于等于、小于、小于等于）")
        }
    default:
        err = errors.New("条件判断目前仅支持字符串、整型。")
    }

    return
}

// 并行网关，确认其他节点是否完成
func (h *Handle) completeAllParallel(c *gin.Context, target string) (statusOk bool, err error) {
    var (
        stateList []map[string]interface{}
    )

    err = json.Unmarshal(h.workOrderDetails.State, &stateList)
    if err != nil {
        err = fmt.Errorf("反序列化失败，%v", err.Error())
        return
    }

continueHistoryTag:
    for _, v := range h.cirHistoryList {
        status := false
        for i, s := range stateList {
            if v.Source == s["id"].(string) && v.Target == target {
                status = true
                stateList = append(stateList[:i], stateList[i+1:]...)
                continue continueHistoryTag
            }
        }
        if !status {
            break
        }
    }

    if len(stateList) == 1 && stateList[0]["id"].(string) == h.stateValue["id"] {
        statusOk = true
    }

    return
}

func (h *Handle) commonProcessing(c *gin.Context) (err error) {
    // 如果是拒绝的流转则直接跳转
    if h.flowProperties == 0 {
        err = h.circulation()
        if err != nil {
            err = fmt.Errorf("工单跳转失败，%v", err.Error())
        }
        return
    }

    // 会签
    if h.stateValue["assignValue"] != nil && len(h.stateValue["assignValue"].([]interface{})) > 1 {
        if isCounterSign, ok := h.stateValue["isCounterSign"]; ok {
            if isCounterSign.(bool) {
                h.endHistory = false
                err = h.Countersign(c)
                if err != nil {
                    return
                }
            } else {
                err = h.circulation()
                if err != nil {
                    return
                }
            }
        } else {
            err = h.circulation()
            if err != nil {
                return
            }
        }
    } else {
        err = h.circulation()
        if err != nil {
            return
        }
    }
    return
}

func (h *Handle) HandleWorkOrder(
    c *gin.Context,
    workOrderId int,
    tasks []string,
    targetState string,
    sourceState string,
    circulationValue string,
    flowProperties int,
    remarks string,
) (err error) {
    h.workOrderId = workOrderId
    h.flowProperties = flowProperties
    h.endHistory = true

    var (
        execTasks          []string
        relatedPersonList  []int
        cirHistoryValue    []process.CirculationHistory
        cirHistoryData     process.CirculationHistory
        costDurationValue  string
        sourceEdges        []map[string]interface{}
        targetEdges        []map[string]interface{}
        condExprStatus     bool
        relatedPersonValue []byte
        parallelStatusOk   bool
        processInfo        process.Info
        currentUserInfo    system.SysUser
        sendToUserList     []system.SysUser
        noticeList         []int
        sendSubject        string = "您有一条待办工单，请及时处理"
        sendDescription    string = "您有一条待办工单请及时处理，工单描述如下"
    )

    defer func() {
        if r := recover(); r != nil {
            switch e := r.(type) {
            case string:
                err = errors.New(e)
            case error:
                err = e
            default:
                err = errors.New("未知错误")
            }
            return
        }
    }()

    // 获取工单信息
    err = orm.Eloquent.Model(&process.WorkOrderInfo{}).Where("id = ?", workOrderId).Find(&h.workOrderDetails).Error
    if err != nil {
        return
    }

    // 获取流程信息
    err = orm.Eloquent.Model(&process.Info{}).Where("id = ?", h.workOrderDetails.Process).Find(&processInfo).Error
    if err != nil {
        return
    }
    err = json.Unmarshal(processInfo.Structure, &h.processState.Structure)
    if err != nil {
        return
    }

    // 获取当前节点
    h.stateValue, err = h.processState.GetNode(sourceState)
    if err != nil {
        return
    }

    // 目标状态
    h.targetStateValue, err = h.processState.GetNode(targetState)
    if err != nil {
        return
    }

    // 获取工单数据
    err = orm.Eloquent.Model(&process.TplData{}).
        Where("work_order = ?", workOrderId).
        Pluck("form_data", &h.workOrderData).Error
    if err != nil {
        return
    }

    // 根据处理人查询出需要会签的条数
    err = orm.Eloquent.Model(&process.CirculationHistory{}).
        Where("work_order = ?", workOrderId).
        Order("id desc").
        Find(&h.cirHistoryList).Error
    if err != nil {
        return
    }

    err = json.Unmarshal(h.workOrderDetails.RelatedPerson, &relatedPersonList)
    if err != nil {
        return
    }
    relatedPersonStatus := false
    for _, r := range relatedPersonList {
        if r == tools.GetUserId(c) {
            relatedPersonStatus = true
            break
        }
    }
    if !relatedPersonStatus {
        relatedPersonList = append(relatedPersonList, tools.GetUserId(c))
    }

    relatedPersonValue, err = json.Marshal(relatedPersonList)
    if err != nil {
        return
    }

    h.updateValue = map[string]interface{}{
        "related_person": relatedPersonValue,
    }

    // 开启事务
    h.tx = orm.Eloquent.Begin()

    stateValue := map[string]interface{}{
        "label": h.targetStateValue["label"].(string),
        "id":    h.targetStateValue["id"].(string),
    }

    switch h.targetStateValue["clazz"] {
    // 排他网关
    case "exclusiveGateway":
        sourceEdges, err = h.processState.GetEdge(h.targetStateValue["id"].(string), "source")
        if err != nil {
            return
        }
    breakTag:
        for _, edge := range sourceEdges {
            edgeCondExpr := make([]map[string]interface{}, 0)
            err = json.Unmarshal([]byte(edge["conditionExpression"].(string)), &edgeCondExpr)
            if err != nil {
                return
            }
            for _, condExpr := range edgeCondExpr {
                // 条件判断
                condExprStatus, err = h.ConditionalJudgment(condExpr)
                if err != nil {
                    return
                }
                if condExprStatus {
                    // 进行节点跳转
                    h.targetStateValue, err = h.processState.GetNode(edge["target"].(string))
                    if err != nil {
                        return
                    }

                    if h.targetStateValue["clazz"] == "userTask" || h.targetStateValue["clazz"] == "receiveTask" {
                        if h.targetStateValue["assignValue"] == nil || h.targetStateValue["assignType"] == "" {
                            err = errors.New("处理人不能为空")
                            return
                        }
                    }

                    h.updateValue["state"] = []map[string]interface{}{{
                        "id":             h.targetStateValue["id"].(string),
                        "label":          h.targetStateValue["label"],
                        "processor":      h.targetStateValue["assignValue"],
                        "process_method": h.targetStateValue["assignType"],
                    }}
                    err = h.commonProcessing(c)
                    if err != nil {
                        err = fmt.Errorf("流程流程跳转失败，%v", err.Error())
                        return
                    }

                    break breakTag
                }
            }
        }
        if !condExprStatus {
            err = errors.New("所有流转均不符合条件，请确认。")
            return
        }
    // 并行/聚合网关
    case "parallelGateway":
        // 入口，判断
        sourceEdges, err = h.processState.GetEdge(h.targetStateValue["id"].(string), "source")
        if err != nil {
            err = fmt.Errorf("查询流转信息失败，%v", err.Error())
            return
        }

        targetEdges, err = h.processState.GetEdge(h.targetStateValue["id"].(string), "target")
        if err != nil {
            err = fmt.Errorf("查询流转信息失败，%v", err.Error())
            return
        }

        if len(sourceEdges) > 0 {
            h.targetStateValue, err = h.processState.GetNode(sourceEdges[0]["target"].(string))
            if err != nil {
                return
            }
        } else {
            err = errors.New("并行网关流程不正确")
            return
        }

        if len(sourceEdges) > 1 && len(targetEdges) == 1 {
            // 入口
            h.updateValue["state"] = make([]map[string]interface{}, 0)
            for _, edge := range sourceEdges {
                targetStateValue, err := h.processState.GetNode(edge["target"].(string))
                if err != nil {
                    return err
                }
                h.updateValue["state"] = append(h.updateValue["state"].([]map[string]interface{}), map[string]interface{}{
                    "id":             edge["target"].(string),
                    "label":          targetStateValue["label"],
                    "processor":      targetStateValue["assignValue"],
                    "process_method": targetStateValue["assignType"],
                })
            }
            err = h.circulation()
            if err != nil {
                err = fmt.Errorf("工单跳转失败，%v", err.Error())
                return
            }
        } else if len(sourceEdges) == 1 && len(targetEdges) > 1 {
            // 出口
            parallelStatusOk, err = h.completeAllParallel(c, sourceEdges[0]["target"].(string))
            if err != nil {
                err = fmt.Errorf("并行检测失败，%v", err.Error())
                return
            }
            if parallelStatusOk {
                h.endHistory = true
                endAssignValue, ok := h.targetStateValue["assignValue"]
                if !ok {
                    endAssignValue = []int{}
                }

                endAssignType, ok := h.targetStateValue["assignType"]
                if !ok {
                    endAssignType = ""
                }

                h.updateValue["state"] = []map[string]interface{}{{
                    "id":             h.targetStateValue["id"].(string),
                    "label":          h.targetStateValue["label"],
                    "processor":      endAssignValue,
                    "process_method": endAssignType,
                }}
                err = h.circulation()
                if err != nil {
                    err = fmt.Errorf("工单跳转失败，%v", err.Error())
                    return
                }
            } else {
                h.endHistory = false
            }

        } else {
            err = errors.New("并行网关流程不正确")
            return
        }
    // 包容网关
    case "inclusiveGateway":
        return
    case "start":
        stateValue["processor"] = []int{h.workOrderDetails.Creator}
        stateValue["process_method"] = "person"
        h.updateValue["state"] = []map[string]interface{}{stateValue}
        err = h.circulation()
        if err != nil {
            return
        }
    case "userTask":
        stateValue["processor"] = h.targetStateValue["assignValue"].([]interface{})
        stateValue["process_method"] = h.targetStateValue["assignType"].(string)
        h.updateValue["state"] = []map[string]interface{}{stateValue}
        err = h.commonProcessing(c)
        if err != nil {
            return
        }
    case "receiveTask":
        stateValue["processor"] = h.targetStateValue["assignValue"].([]interface{})
        stateValue["process_method"] = h.targetStateValue["assignType"].(string)
        h.updateValue["state"] = []map[string]interface{}{stateValue}
        err = h.commonProcessing(c)
        if err != nil {
            return
        }
    case "scriptTask":
        stateValue["processor"] = []int{}
        stateValue["process_method"] = ""
        h.updateValue["state"] = []map[string]interface{}{stateValue}
    case "end":
        stateValue["processor"] = []int{}
        stateValue["process_method"] = ""
        h.updateValue["state"] = []map[string]interface{}{stateValue}
        err = h.circulation()
        if err != nil {
            h.tx.Rollback()
            return
        }
        err = h.tx.Model(&process.WorkOrderInfo{}).
            Where("id = ?", h.workOrderId).
            Update("is_end", 1).Error
        if err != nil {
            h.tx.Rollback()
            return
        }
    }

    // 流转历史写入
    err = orm.Eloquent.Model(&cirHistoryValue).
        Where("work_order = ?", workOrderId).
        Find(&cirHistoryValue).
        Order("create_time desc").Error
    if err != nil {
        h.tx.Rollback()
        return
    }
    for _, t := range cirHistoryValue {
        if t.Source != h.stateValue["id"] {
            costDuration := time.Since(t.CreatedAt.Time)
            costDurationValue = fmtDuration(costDuration)
        }
    }

    // 获取当前用户信息
    err = orm.Eloquent.Model(¤tUserInfo).
        Where("user_id = ?", tools.GetUserId(c)).
        Find(¤tUserInfo).Error
    if err != nil {
        return
    }

    cirHistoryData = process.CirculationHistory{
        Model:        base.Model{},
        Title:        h.workOrderDetails.Title,
        WorkOrder:    h.workOrderDetails.Id,
        State:        h.stateValue["label"].(string),
        Source:       h.stateValue["id"].(string),
        Target:       h.targetStateValue["id"].(string),
        Circulation:  circulationValue,
        Processor:    currentUserInfo.NickName,
        ProcessorId:  tools.GetUserId(c),
        CostDuration: costDurationValue,
        Remarks:      remarks,
    }

    err = h.tx.Create(&cirHistoryData).Error
    if err != nil {
        h.tx.Rollback()
        return
    }

    // 获取流程通知类型列表
    err = json.Unmarshal(processInfo.Notice, ¬iceList)
    if err != nil {
        return
    }

    bodyData := notify.BodyData{
        SendTo: map[string]interface{}{
            "userList": sendToUserList,
        },
        Subject:     sendSubject,
        Description: sendDescription,
        Classify:    noticeList,
        ProcessId:   h.workOrderDetails.Process,
        Id:          h.workOrderDetails.Id,
        Title:       h.workOrderDetails.Title,
        Creator:     currentUserInfo.NickName,
        Priority:    h.workOrderDetails.Priority,
        CreatedAt:   h.workOrderDetails.CreatedAt.Format("2006-01-02 15:04:05"),
    }

    // 判断目标是否是结束节点
    if h.targetStateValue["clazz"] == "end" && h.endHistory == true {
        sendSubject = "您的工单已处理完成"
        sendDescription = "您的工单已处理完成，工单描述如下"
        err = h.tx.Create(&process.CirculationHistory{
            Model:       base.Model{},
            Title:       h.workOrderDetails.Title,
            WorkOrder:   h.workOrderDetails.Id,
            State:       h.targetStateValue["label"].(string),
            Source:      h.targetStateValue["id"].(string),
            Processor:   currentUserInfo.NickName,
            ProcessorId: tools.GetUserId(c),
            Circulation: "结束",
            Remarks:     "工单已结束",
        }).Error
        if err != nil {
            h.tx.Rollback()
            return
        }
        if len(noticeList) > 0 {
            // 查询工单创建人信息
            err = h.tx.Model(&system.SysUser{}).
                Where("user_id = ?", h.workOrderDetails.Creator).
                Find(&sendToUserList).Error
            if err != nil {
                return
            }

            bodyData.SendTo = map[string]interface{}{
                "userList": sendToUserList,
            }
            bodyData.Subject = sendSubject
            bodyData.Description = sendDescription

            // 发送通知
            go func(bodyData notify.BodyData) {
                err = bodyData.SendNotify()
                if err != nil {
                    return
                }
            }(bodyData)
        }
    }

    h.tx.Commit() // 提交事务

    // 发送通知
    if len(noticeList) > 0 {
        stateList := make([]interface{}, 0)
        for _, v := range h.updateValue["state"].([]map[string]interface{}) {
            stateList = append(stateList, v)
        }
        sendToUserList, err = GetPrincipalUserInfo(stateList, h.workOrderDetails.Creator)
        if err != nil {
            return
        }

        bodyData.SendTo = map[string]interface{}{
            "userList": sendToUserList,
        }
        bodyData.Subject = sendSubject
        bodyData.Description = sendDescription

        // 发送通知
        go func(bodyData notify.BodyData) {
            err = bodyData.SendNotify()
            if err != nil {
                return
            }
        }(bodyData)
    }

    // 执行流程公共任务及节点任务
    if h.stateValue["task"] != nil {
        for _, task := range h.stateValue["task"].([]interface{}) {
            tasks = append(tasks, task.(string))
        }
    }
continueTag:
    for _, task := range tasks {
        for _, t := range execTasks {
            if t == task {
                continue continueTag
            }
        }
        execTasks = append(execTasks, task)
    }
    go ExecTask(execTasks)

    return
}

ok, anyway.

加上一段在公司经常听到英文作为结束语，如果能实现本文的这些功能，其实一个简单易用，灵活方便维护管理的工单系统就成型了。

在此给大家说声抱歉，无法将完整的代码贴在这里（因为实在是太多了），如果大家还有什么疑问的话，欢迎随时来我的博客留言。