工作流1

server/api/v1/enter.go

@@ -4,12 +4,14 @@ import (
 	"server/api/v1/admin"
 	"server/api/v1/example"
 	"server/api/v1/system"
+	"server/api/v1/workflow"
 )
 
 type ApiGroup struct {
-	SystemApiGroup  system.ApiGroup
-	ExampleApiGroup example.ApiGroup
-	AdminApiGroup   admin.ApiGroup
+	SystemApiGroup   system.ApiGroup
+	ExampleApiGroup  example.ApiGroup
+	AdminApiGroup    admin.ApiGroup
+	WorkflowApiGroup workflow.ApiGroup
 }
 
 var ApiGroupApp = new(ApiGroup)

server/api/v1/workflow/approver.go

@@ -0,0 +1,94 @@
+package workflow
+
+import (
+	"github.com/gin-gonic/gin"
+	"server/dao"
+	"server/global"
+	"server/model/common/request"
+	"server/model/common/response"
+)
+
+type ApproverApi struct{}
+
+func (aa *ApproverApi) QueryAllApprover(c *gin.Context) {
+	approvers, err := approverService.QueryAllApprover()
+	if err != nil {
+		response.FailWithMessage("查询失败", c)
+		global.GVA_LOG.Error("QueryAllApprover ==" + err.Error())
+		return
+	}
+	response.OkWithData(approvers, c)
+}
+
+func (aa *ApproverApi) QueryApproverList(c *gin.Context) {
+	var info request.PageInfo
+	err := c.ShouldBindJSON(&info)
+	if err != nil {
+		response.FailWithMessage("失败", c)
+		global.GVA_LOG.Error("QueryApproverList ====== " + err.Error())
+		return
+	}
+	list, total, err := approverService.QueryApproverList(info)
+	if err != nil {
+		response.FailWithMessage("查询失败", c)
+		global.GVA_LOG.Error("QueryApproverList ====== " + err.Error())
+		return
+	}
+	response.OkWithDetailed(response.PageResult{
+		List:     list,
+		Total:    total,
+		Page:     info.Page,
+		PageSize: info.PageSize,
+	}, "获取成功", c)
+}
+
+func (aa *ApproverApi) CreateApprover(c *gin.Context) {
+	var approver dao.Approver
+	err := c.ShouldBindJSON(&approver)
+	if err != nil {
+		response.FailWithMessage("失败", c)
+		global.GVA_LOG.Error("CreateApprover ====== " + err.Error())
+		return
+	}
+	err = approverService.CreateApprover(approver)
+	if err != nil {
+		response.FailWithMessage("失败", c)
+		global.GVA_LOG.Error("CreateApprover ====== " + err.Error())
+		return
+	}
+	response.OkWithMessage("新增成功", c)
+}
+
+func (aa *ApproverApi) UpdateApprover(c *gin.Context) {
+	var approver dao.Approver
+	err := c.ShouldBindJSON(&approver)
+	if err != nil {
+		response.FailWithMessage("失败", c)
+		global.GVA_LOG.Error("UpdateApprover ====== " + err.Error())
+		return
+	}
+	err = approverService.UpdateApprover(approver)
+	if err != nil {
+		response.FailWithMessage("失败", c)
+		global.GVA_LOG.Error("UpdateApprover ====== " + err.Error())
+		return
+	}
+	response.OkWithMessage("修改成功", c)
+}
+
+func (aa *ApproverApi) DeleteApprover(c *gin.Context) {
+	var approver dao.Approver
+	err := c.ShouldBindJSON(&approver)
+	if err != nil {
+		response.FailWithMessage("参数错误", c)
+		global.GVA_LOG.Error("DeleteApprover ====== " + err.Error())
+		return
+	}
+	err = approverService.DeleteApprover(approver)
+	if err != nil {
+		response.FailWithMessage("失败", c)
+		global.GVA_LOG.Error("DeleteApprover ====== " + err.Error())
+		return
+	}
+	response.OkWithMessage("删除成功", c)
+}

server/api/v1/workflow/description.go

@@ -0,0 +1,3 @@
+package workflow
+
+type DescriptionApi struct{}

server/api/v1/workflow/enter.go

@@ -0,0 +1,19 @@
+package workflow
+
+import "server/service"
+
+type ApiGroup struct {
+	ApproverApi
+	DescriptionApi
+	NodeApi
+	ProcessApi
+	ProjectProcessApi
+}
+
+var (
+	approverService       = service.ServiceGroupApp.WorkflowServiceGroup.ApproverService
+	descriptionService    = service.ServiceGroupApp.WorkflowServiceGroup.DescriptionService
+	nodeService           = service.ServiceGroupApp.WorkflowServiceGroup.NodeService
+	processService        = service.ServiceGroupApp.WorkflowServiceGroup.ProcessService
+	projectProcessService = service.ServiceGroupApp.WorkflowServiceGroup.ProjectProcessService
+)

server/api/v1/workflow/node.go

@@ -0,0 +1,112 @@
+package workflow
+
+import (
+	"github.com/gin-gonic/gin"
+	"server/dao"
+	"server/global"
+	"server/model/common/request"
+	"server/model/common/response"
+	"strconv"
+)
+
+type NodeApi struct{}
+
+func (na *NodeApi) QueryAllNode(c *gin.Context) {
+	nodes, err := nodeService.QueryAllNode()
+	if err != nil {
+		response.FailWithMessage("查询失败", c)
+		global.GVA_LOG.Error("QueryAllNode ==" + err.Error())
+		return
+	}
+	response.OkWithData(nodes, c)
+}
+
+func (na *NodeApi) QueryNodeList(c *gin.Context) {
+	var info request.PageInfo
+	err := c.ShouldBindJSON(&info)
+	if err != nil {
+		response.FailWithMessage("参数错误", c)
+		global.GVA_LOG.Error("QueryNodeList ====== " + err.Error())
+		return
+	}
+	list, total, err := nodeService.QueryNodeList(info)
+	if err != nil {
+		response.FailWithMessage("查询失败", c)
+		global.GVA_LOG.Error("QueryNodeList ====== " + err.Error())
+		return
+	}
+	response.OkWithDetailed(response.PageResult{
+		List:     list,
+		Total:    total,
+		Page:     info.Page,
+		PageSize: info.PageSize,
+	}, "获取成功", c)
+}
+
+func (na *NodeApi) QueryNodeByApproverId(c *gin.Context) {
+	id := c.Param("approverId")
+	approverId, err := strconv.Atoi(id)
+	if err != nil {
+		response.FailWithMessage("参数错误", c)
+		global.GVA_LOG.Error("QueryNodeByApproverId ====== " + err.Error())
+		return
+	}
+	node, err := nodeService.QueryNodeByApproverId(approverId)
+	if err != nil {
+		response.FailWithMessage("查询失败", c)
+		global.GVA_LOG.Error("QueryNodeByApproverId ====== " + err.Error())
+		return
+	}
+	response.OkWithData(node, c)
+}
+
+func (na *NodeApi) CreateNode(c *gin.Context) {
+	var node dao.Node
+	err := c.ShouldBindJSON(&node)
+	if err != nil {
+		response.FailWithMessage("参数错误", c)
+		global.GVA_LOG.Error("CreateNode ====== " + err.Error())
+		return
+	}
+	err = nodeService.CreateNode(node)
+	if err != nil {
+		response.FailWithMessage("创建失败", c)
+		global.GVA_LOG.Error("CreateNode ====== " + err.Error())
+		return
+	}
+	response.OkWithMessage("创建成功", c)
+}
+
+func (na *NodeApi) UpdateNode(c *gin.Context) {
+	var node dao.Node
+	err := c.ShouldBindJSON(&node)
+	if err != nil {
+		response.FailWithMessage("参数错误", c)
+		global.GVA_LOG.Error("UpdateNode ====== " + err.Error())
+		return
+	}
+	err = nodeService.UpdateNode(node)
+	if err != nil {
+		response.FailWithMessage("更新失败", c)
+		global.GVA_LOG.Error("UpdateNode ====== " + err.Error())
+		return
+	}
+	response.OkWithMessage("更新成功", c)
+}
+
+func (na *NodeApi) DeleteNode(c *gin.Context) {
+	var node dao.Node
+	err := c.ShouldBindJSON(&node)
+	if err != nil {
+		response.FailWithMessage("参数错误", c)
+		global.GVA_LOG.Error("UpdateNode ====== " + err.Error())
+		return
+	}
+	err = nodeService.DeleteNode(node)
+	if err != nil {
+		response.FailWithMessage("删除失败", c)
+		global.GVA_LOG.Error("DeleteNode ====== " + err.Error())
+		return
+	}
+	response.OkWithMessage("删除成功", c)
+}

server/api/v1/workflow/process.go

@@ -0,0 +1,94 @@
+package workflow
+
+import (
+	"github.com/gin-gonic/gin"
+	"server/dao"
+	"server/global"
+	"server/model/common/request"
+	"server/model/common/response"
+)
+
+type ProcessApi struct{}
+
+func (pa *ProcessApi) QueryAllProcess(c *gin.Context) {
+	process, err := processService.QueryAllProcess()
+	if err != nil {
+		response.FailWithMessage("查询失败", c)
+		global.GVA_LOG.Error("QueryAllProcess ====== " + err.Error())
+		return
+	}
+	response.OkWithData(process, c)
+}
+
+func (pa *ProcessApi) QueryProcessList(c *gin.Context) {
+	var info request.PageInfo
+	err := c.ShouldBindJSON(&info)
+	if err != nil {
+		response.FailWithMessage("参数解析失败", c)
+		global.GVA_LOG.Error("QueryProcessList ====== " + err.Error())
+		return
+	}
+	list, total, err := processService.QueryProcessList(info)
+	if err != nil {
+		response.FailWithMessage("查询失败", c)
+		global.GVA_LOG.Error("QueryProcessList ====== " + err.Error())
+		return
+	}
+	response.OkWithDetailed(response.PageResult{
+		List:     list,
+		Total:    total,
+		Page:     info.Page,
+		PageSize: info.PageSize,
+	}, "获取成功", c)
+}
+
+func (pa *ProcessApi) CreateProcess(c *gin.Context) {
+	var process dao.Process
+	err := c.ShouldBindJSON(&process)
+	if err != nil {
+		response.FailWithMessage("参数解析失败", c)
+		global.GVA_LOG.Error("CreateProcess ====== " + err.Error())
+		return
+	}
+	err = processService.CreateProcess(process)
+	if err != nil {
+		response.FailWithMessage("创建失败", c)
+		global.GVA_LOG.Error("CreateProcess ====== " + err.Error())
+		return
+	}
+	response.OkWithMessage("创建成功", c)
+}
+
+func (pa *ProcessApi) UpdateProcess(c *gin.Context) {
+	var process dao.Process
+	err := c.ShouldBindJSON(&process)
+	if err != nil {
+		response.FailWithMessage("参数解析失败", c)
+		global.GVA_LOG.Error("UpdateProcess ====== " + err.Error())
+		return
+	}
+	err = processService.UpdateProcess(process)
+	if err != nil {
+		response.FailWithMessage("更新失败", c)
+		global.GVA_LOG.Error("UpdateProcess ====== " + err.Error())
+		return
+	}
+	response.OkWithMessage("更新成功", c)
+}
+
+func (pa *ProcessApi) DeleteProcess(c *gin.Context) {
+	var process dao.Process
+	err := c.ShouldBindJSON(&process)
+	if err != nil {
+		response.FailWithMessage("参数解析失败", c)
+		global.GVA_LOG.Error("UpdateProcess ====== " + err.Error())
+		return
+	}
+	err = processService.DeleteProcess(process)
+	if err != nil {
+		response.FailWithMessage("删除失败", c)
+		global.GVA_LOG.Error("DeleteProcess ====== " + err.Error())
+		return
+	}
+	response.OkWithMessage("删除成功", c)
+}

server/api/v1/workflow/project_process.go

@@ -0,0 +1,3 @@
+package workflow
+
+type ProjectProcessApi struct{}

server/dao/approver.go

@@ -0,0 +1,49 @@
+package dao
+
+import "server/global"
+
+type Approver struct {
+	global.GVA_MODEL
+	UserId                    int     `json:"userId" form:"userId" gorm:"comment:用户id"`
+	User                      SysUser `json:"user" form:"user" gorm:"foreignKey:UserId;references:id;"`
+	ApproverDescription       string  `json:"approverDescription" form:"approverDescription" gorm:"comment:审批人详情"`
+	ApproverRightsDescription string  `json:"approverRightsDescription" form:"approverRightsDescription" gorm:"comment:审批人权限详情"`
+}
+
+func (Approver) TableName() string {
+	return "approver"
+}
+
+func QueryAllApprover() (approvers []Approver, err error) {
+	err = global.GVA_DB.Model(&Approver{}).Preload("User").Find(&approvers).Error
+	return approvers, err
+}
+
+func QueryApproverList(limit, offset int) (approvers []Approver, total int64, err error) {
+	// 创建db
+	db := global.GVA_DB.Model(&Approver{})
+	// 如果有条件搜索 下方会自动创建搜索语句
+	err = db.Count(&total).Error
+	if err != nil {
+		return
+	}
+	err = db.Order("id desc").Limit(limit).Offset(offset).Preload("User").Find(&approvers).Error
+	return approvers, total, err
+}
+
+func QueryApproverByUserId(userId int) (approver Approver, err error) {
+	err = global.GVA_DB.Model(&Approver{}).Where("user_id = ?", userId).Preload("User").First(&approver).Error
+	return approver, err
+}
+
+func (a Approver) CreateApprover() error {
+	return global.GVA_DB.Create(&a).Error
+}
+
+func (a Approver) UpdateApprover() error {
+	return global.GVA_DB.Where("id = ?", a.ID).Updates(&a).Error
+}
+
+func (a Approver) DeleteApprover() error {
+	return global.GVA_DB.Unscoped().Delete(&a).Error
+}

server/dao/description.go

@@ -0,0 +1,34 @@
+package dao
+
+import "server/global"
+
+type Description struct {
+	global.GVA_MODEL
+	ProjectProcessId int    `json:"projectProcessId" form:"projectProcessId" gorm:"comment:项目审批id"`
+	ApprovalOpinion  string `json:"approvalOpinion" form:"approvalOpinion" gorm:"comment:审批意见"`
+	NodeId           int    `json:"nodeId" form:"nodeId" gorm:"comment:节点id"`
+	Node             Node   `json:"node" form:"node" gorm:"foreignKey:NodeId;references:id;"`
+	ApprovalTime     string `json:"approvalTime" form:"approvalTime" gorm:"comment:审批时间"`
+	OptionResult     string `json:"optionResult" form:"optionResult" gorm:"comment:操作结果"`
+}
+
+func (Description) TableName() string {
+	return "description"
+}
+
+func QueryDescriptionByProjectProcessId(projectProcessId int) (descriptions []Description, err error) {
+	err = global.GVA_DB.Model(&Description{}).Where("projectProcessId=?", projectProcessId).Find(&descriptions).Error
+	return descriptions, err
+}
+
+func (d Description) CreateDescription() error {
+	return global.GVA_DB.Create(&d).Error
+}
+
+func (d Description) UpdateDescription() error {
+	return global.GVA_DB.Where("id = ?", d.ID).Updates(&d).Error
+}
+
+func (d Description) DeleteDescription() error {
+	return global.GVA_DB.Unscoped().Delete(&d).Error
+}

server/dao/node.go

@@ -0,0 +1,56 @@
+package dao
+
+import "server/global"
+
+type Node struct {
+	global.GVA_MODEL
+	NodeName        string     `json:"nodeName" form:"nodeName" gorm:"comment:审批节点名称"`
+	ApproverId      int        `json:"approverId" form:"approverId" gorm:"comment:审批人id"`
+	Approver        Approver   `json:"approver" form:"approver" gorm:"foreignKey:ApproverId;references:id;"`
+	NodeOrder       int        `json:"nodeOrder" form:"nodeOrder" gorm:"comment:节点顺序"`
+	NodeDescription string     `json:"nodeDescription" form:"nodeDescription" gorm:"comment:节点描述"`
+	Processes       []*Process `json:"processes" form:"processes" gorm:"many2many:process_nodes;"`
+}
+
+func (Node) TableName() string {
+	return "node"
+}
+
+func QueryAllNode() (nodes []Node, err error) {
+	err = global.GVA_DB.Model(&Node{}).Preload("Approver").Find(&nodes).Error
+	return nodes, err
+}
+
+func QueryNodeList(limit, offset int) (nodes []Node, total int64, err error) {
+	// 创建db
+	db := global.GVA_DB.Model(&Node{})
+	// 如果有条件搜索 下方会自动创建搜索语句
+	err = db.Count(&total).Error
+	if err != nil {
+		return
+	}
+	err = db.Order("id desc").Limit(limit).Offset(offset).Preload("Approver").Find(&nodes).Error
+	return nodes, total, err
+}
+
+func QueryNodeById(id int) (node Node, err error) {
+	err = global.GVA_DB.Model(&Node{}).Where("id = ?", id).Preload("Approver").First(&node).Error
+	return node, err
+}
+
+func QueryNodeByApproverId(approverId int) (nodes []Node, err error) {
+	err = global.GVA_DB.Model(&Node{}).Where("approver_id = ?", approverId).Preload("Approver").Find(&nodes).Error
+	return nodes, err
+}
+
+func (n Node) CreateNode() error {
+	return global.GVA_DB.Create(&n).Error
+}
+
+func (n Node) UpdateNode() error {
+	return global.GVA_DB.Where("id = ?", n.ID).Updates(&n).Error
+}
+
+func (n Node) DeleteNode() error {
+	return global.GVA_DB.Unscoped().Delete(&n).Error
+}

server/dao/process.go

@@ -0,0 +1,52 @@
+package dao
+
+import "server/global"
+
+type Process struct {
+	global.GVA_MODEL
+	ProcessName    string `json:"processName" form:"processName" gorm:"comment:审批流程名称"`
+	ProcessContent string `json:"processContent" form:"processContent" gorm:"审批流程内容"`
+	ProcessType    string `json:"processType" form:"processType" gorm:"审批流程类型"`
+	Nodes          []Node `json:"nodes" form:"nodes" gorm:"many2many:process_nodes;"`
+}
+
+func (Process) TableName() string {
+	return "process"
+}
+
+func QueryAllProcess() (processes []Process, err error) {
+	err = global.GVA_DB.Model(&Process{}).Find(&processes).Error
+	return processes, err
+}
+
+func QueryProcessList(limit, offset int) (processes []Process, total int64, err error) {
+	// 创建db
+	db := global.GVA_DB.Model(&Process{})
+	// 如果有条件搜索 下方会自动创建搜索语句
+	err = db.Count(&total).Error
+	if err != nil {
+		return
+	}
+	err = db.Order("id desc").Limit(limit).Offset(offset).Find(&processes).Error
+	return processes, total, err
+}
+
+func QueryProcessById(id int) (process Process, err error) {
+	err = global.GVA_DB.Model(&Process{}).Where("id = ?", id).Find(&process).Error
+	return process, err
+}
+
+func (p Process) CreateProcess() error {
+	err := global.GVA_DB.Create(&p).Error
+	return err
+}
+
+func (p Process) UpdateProcess() error {
+	err := global.GVA_DB.Where("id = ?", p.ID).Updates(&p).Error
+	return err
+}
+
+func (p Process) DeleteProcess() error {
+	err := global.GVA_DB.Unscoped().Delete(&p).Error
+	return err
+}

server/dao/project_process.go

@@ -0,0 +1,61 @@
+package dao
+
+import "server/global"
+
+type ProjectProcess struct {
+	global.GVA_MODEL
+	ProjectProcessName string        `json:"projectProcessName" form:"projectProcessName" gorm:"comment:项目审批名称"`
+	ProjectId          int           `json:"projectId" form:"projectId" gorm:"comment:项目id"`
+	Project            Project       `json:"project" form:"project" gorm:"foreignKey:ProjectId;references:id;"`
+	Applicant          int           `json:"applicant" form:"applicant" gorm:"comment:申请人"`
+	User               SysUser       `json:"user" form:"user" gorm:"foreignKey:Applicant;references:id;"`
+	CurrentNodeOrder   int           `json:"currentNodeOrder" form:"currentNodeOrder" gorm:"comment:当前审批节点id"`
+	Node               Node          `json:"node" form:"node" gorm:"foreignKey:CurrentNodeOrder;references:id;"`
+	ProcessApprovalId  int           `json:"processApprovalId" form:"processApprovalId" gorm:"comment:当前审批流程id"`
+	Process            Process       `json:"process" form:"process" gorm:"foreignKey:ProcessApprovalId;references:id"`
+	ProjectType        string        `json:"projectType" form:"projectType" gorm:"comment:项目类型"`
+	Descriptions       []Description `json:"descriptions" form:"descriptions" gorm:"foreignKey:ProjectProcessId;"`
+}
+
+func (ProjectProcess) TableName() string {
+	return "project_process"
+}
+
+func QueryProjectApplicantList(limit, offset, applicant int) (projectProcesses []ProjectProcess, total int64, err error) {
+	// 创建db
+	db := global.GVA_DB.Model(&ProjectProcess{})
+	// 如果有条件搜索 下方会自动创建搜索语句
+	if applicant != 0 {
+		db = db.Where("applicant = ?", applicant)
+	}
+	err = db.Count(&total).Error
+	if err != nil {
+		return
+	}
+	err = db.Order("id desc").Limit(limit).Offset(offset).Preload("Project").Preload("User").Preload("Node").Preload("Process").Preload("Descriptions").Find(&projectProcesses).Error
+	return projectProcesses, total, err
+}
+
+func QueryProjectProcessList(limit, offset, applicant int) (projectProcesses []ProjectProcess, total int64, err error) {
+	// 创建db
+	db := global.GVA_DB.Model(&ProjectProcess{}).Joins("JOIN node ON project_process.current_node_order = node.id").Where("node.approver_id = ?", applicant)
+	// 如果有条件搜索 下方会自动创建搜索语句
+	err = db.Count(&total).Error
+	if err != nil {
+		return
+	}
+	err = db.Order("id desc").Limit(limit).Offset(offset).Preload("Project").Preload("User").Preload("Node").Preload("Process").Preload("Descriptions").Find(&projectProcesses).Error
+	return projectProcesses, total, err
+}
+
+func (pp ProjectProcess) CreateProjectProcess() error {
+	return global.GVA_DB.Create(&pp).Error
+}
+
+func (pp ProjectProcess) UpdateProjectProcess() error {
+	return global.GVA_DB.Where("id = ?", pp.ID).Updates(&pp).Error
+}
+
+func (pp ProjectProcess) DeleteProjectProcess() error {
+	return global.GVA_DB.Unscoped().Delete(&pp).Error
+}

server/initialize/gorm.go

@@ -67,6 +67,10 @@ func RegisterTables() {
 		dao.ProjectFee{},
 		dao.ProjectFeeGenre{},
 		dao.ProjectMonthFee{},
+
+		dao.Node{},
+		dao.Approver{},
+		dao.Process{},
 	)
 	if err != nil {
 		global.GVA_LOG.Error("register table failed", zap.Error(err))

server/initialize/job.go

@@ -9,7 +9,7 @@ import (
 func MyJob() {
 	c := cron.New()
 
-	c.AddFunc("0 0 0/1 * * ?", func() {
+	c.AddFunc("0 0 1 * * ? ", func() {
 		err := dao.CreateProjectMonthFee()
 		if err != nil {
 			global.GVA_LOG.Error("CreateProjectMonthFee ====== " + err.Error())

server/initialize/router.go

@@ -43,6 +43,7 @@ func Routers() *gin.Engine {
 	systemRouter := router.RouterGroupApp.System
 	exampleRouter := router.RouterGroupApp.Example
 	adminRouter := router.RouterGroupApp.Admin
+	workflowRouter := router.RouterGroupApp.Workflow
 	// 如果想要不使用nginx代理前端网页，可以修改 web/.env.production 下的
 	// VUE_APP_BASE_API = /
 	// VUE_APP_BASE_PATH = http://localhost
@@ -93,6 +94,8 @@ func Routers() *gin.Engine {
 		adminRouter.InitFinanceRouter(PrivateGroup)
 		adminRouter.InitConstructorRouter(PrivateGroup)
 		adminRouter.InitExpensesRouter(PrivateGroup)
+
+		workflowRouter.InitApproverRouter(PrivateGroup)
 	}
 
 	global.GVA_LOG.Info("router register success")

server/model/common/request/common.go

@@ -91,4 +91,9 @@ type SearchIdNameGenre struct {
 	Genre    int      `json:"genre" form:"genre"`
 }
 
+type SearchProjectProcess struct {
+	PageInfo PageInfo `json:"pageInfo" form:"pageInfo"`
+	UserId   int      `json:"userId" form:"userId"`
+}
+
 type Empty struct{}

server/router/admin/constructor.go

@@ -8,7 +8,7 @@ import (
 
 type ConstructorRouter struct{}
 
-func (s *DepartmentRouter) InitConstructorRouter(Router *gin.RouterGroup) {
+func (s *ConstructorRouter) InitConstructorRouter(Router *gin.RouterGroup) {
 	constructorRouter := Router.Group("constructor").Use(middleware.OperationRecord())
 	constructorRouterWithoutRecord := Router.Group("constructor")
 

server/router/enter.go

@@ -4,12 +4,14 @@ import (
 	"server/router/admin"
 	"server/router/example"
 	"server/router/system"
+	"server/router/workflow"
 )
 
 type RouterGroup struct {
-	System  system.RouterGroup
-	Example example.RouterGroup
-	Admin   admin.RouterGroup
+	System   system.RouterGroup
+	Example  example.RouterGroup
+	Admin    admin.RouterGroup
+	Workflow workflow.RouterGroup
 }
 
 var RouterGroupApp = new(RouterGroup)

server/router/workflow/approver.go

@@ -0,0 +1,25 @@
+package workflow
+
+import (
+	"github.com/gin-gonic/gin"
+	v1 "server/api/v1"
+	"server/middleware"
+)
+
+type ApproverRouter struct{}
+
+func (s *ApproverRouter) InitApproverRouter(Router *gin.RouterGroup) {
+	approverRouter := Router.Group("approver").Use(middleware.OperationRecord())
+	approverRouterWithoutRecord := Router.Group("approver")
+
+	approverApi := v1.ApiGroupApp.WorkflowApiGroup.ApproverApi
+	{
+		approverRouter.POST("createApprover", approverApi.CreateApprover)
+		approverRouter.PUT("updateApprover", approverApi.UpdateApprover)
+		approverRouter.DELETE("deleteApprover", approverApi.DeleteApprover)
+	}
+	{
+		approverRouterWithoutRecord.GET("queryAllApprover", approverApi.QueryAllApprover)
+		approverRouterWithoutRecord.POST("queryApproverList", approverApi.QueryApproverList)
+	}
+}

server/router/workflow/enter.go

@@ -0,0 +1,7 @@
+package workflow
+
+type RouterGroup struct {
+	ApproverRouter
+	NodeRouter
+	ProcessRouter
+}

server/router/workflow/node.go

@@ -0,0 +1,26 @@
+package workflow
+
+import (
+	"github.com/gin-gonic/gin"
+	v1 "server/api/v1"
+	"server/middleware"
+)
+
+type NodeRouter struct{}
+
+func (s *NodeRouter) InitNodeRouter(Router *gin.RouterGroup) {
+	nodeRouter := Router.Group("node").Use(middleware.OperationRecord())
+	nodeRouterWithoutRecord := Router.Group("node")
+
+	nodeApi := v1.ApiGroupApp.WorkflowApiGroup.NodeApi
+	{
+		nodeRouter.POST("createNode", nodeApi.CreateNode)
+		nodeRouter.PUT("updateNode", nodeApi.UpdateNode)
+		nodeRouter.DELETE("deleteNode", nodeApi.DeleteNode)
+	}
+	{
+		nodeRouterWithoutRecord.GET("queryAllNode", nodeApi.QueryAllNode)
+		nodeRouterWithoutRecord.GET("queryNodeByApproverId", nodeApi.QueryNodeByApproverId)
+		nodeRouterWithoutRecord.POST("queryNodeList", nodeApi.QueryNodeList)
+	}
+}

server/router/workflow/process.go

@@ -0,0 +1,25 @@
+package workflow
+
+import (
+	"github.com/gin-gonic/gin"
+	v1 "server/api/v1"
+	"server/middleware"
+)
+
+type ProcessRouter struct{}
+
+func (s *ProcessRouter) InitProcessRouter(Router *gin.RouterGroup) {
+	processRouter := Router.Group("process").Use(middleware.OperationRecord())
+	processRouterWithoutRecord := Router.Group("process")
+
+	processApi := v1.ApiGroupApp.WorkflowApiGroup.ProcessApi
+	{
+		processRouter.POST("createProcess", processApi.CreateProcess)
+		processRouter.PUT("updateProcess", processApi.UpdateProcess)
+		processRouter.DELETE("deleteProcess", processApi.DeleteProcess)
+	}
+	{
+		processRouterWithoutRecord.GET("queryAllProcess", processApi.QueryAllProcess)
+		processRouterWithoutRecord.POST("queryProcessList", processApi.QueryProcessList)
+	}
+}

server/service/enter.go

@@ -4,12 +4,14 @@ import (
 	"server/service/admin"
 	"server/service/example"
 	"server/service/system"
+	"server/service/workflow"
 )
 
 type ServiceGroup struct {
-	SystemServiceGroup  system.ServiceGroup
-	ExampleServiceGroup example.ServiceGroup
-	AdminServiceGroup   admin.ServiceGroup
+	SystemServiceGroup   system.ServiceGroup
+	ExampleServiceGroup  example.ServiceGroup
+	AdminServiceGroup    admin.ServiceGroup
+	WorkflowServiceGroup workflow.ServiceGroup
 }
 
 var ServiceGroupApp = new(ServiceGroup)

server/service/workflow/approver.go

@@ -0,0 +1,40 @@
+package workflow
+
+import (
+	"fmt"
+	"server/dao"
+	"server/model/common/request"
+)
+
+type ApproverService struct {
+}
+
+func (as *ApproverService) QueryAllApprover() (approvers []dao.Approver, err error) {
+	return dao.QueryAllApprover()
+}
+
+func (as *ApproverService) QueryApproverList(info request.PageInfo) (list interface{}, total int64, err error) {
+	limit := info.PageSize
+	offset := info.PageSize * (info.Page - 1)
+	approvers, total, err := dao.QueryApproverList(limit, offset)
+	return approvers, total, err
+}
+
+func (as *ApproverService) CreateApprover(approver dao.Approver) error {
+	return approver.CreateApprover()
+}
+
+func (as *ApproverService) UpdateApprover(approver dao.Approver) error {
+	return approver.UpdateApprover()
+}
+
+func (as *ApproverService) DeleteApprover(approver dao.Approver) error {
+	nodes, err := dao.QueryNodeByApproverId(int(approver.ID))
+	if err != nil {
+		return err
+	}
+	if len(nodes) > 0 {
+		return fmt.Errorf("该数据被使用")
+	}
+	return approver.DeleteApprover()
+}

server/service/workflow/description.go

@@ -0,0 +1,21 @@
+package workflow
+
+import "server/dao"
+
+type DescriptionService struct{}
+
+func (ds *DescriptionService) QueryDescriptionByProjectProcessId(projectProcessId int) (descriptions []dao.Description, err error) {
+	return dao.QueryDescriptionByProjectProcessId(projectProcessId)
+}
+
+func (ds *DescriptionService) CreateDescription(description dao.Description) error {
+	return description.CreateDescription()
+}
+
+func (ds *DescriptionService) UpdateDescription(description dao.Description) error {
+	return description.UpdateDescription()
+}
+
+func (ds *DescriptionService) DeleteDescription(description dao.Description) error {
+	return description.DeleteDescription()
+}

server/service/workflow/enter.go

@@ -0,0 +1,9 @@
+package workflow
+
+type ServiceGroup struct {
+	ApproverService
+	DescriptionService
+	NodeService
+	ProcessService
+	ProjectProcessService
+}

server/service/workflow/node.go

@@ -0,0 +1,47 @@
+package workflow
+
+import (
+	"fmt"
+	"server/dao"
+	"server/model/common/request"
+)
+
+type NodeService struct{}
+
+func (ns *NodeService) QueryAllNode() (nodes []dao.Node, err error) {
+	return dao.QueryAllNode()
+}
+
+func (ns *NodeService) QueryNodeList(info request.PageInfo) (list interface{}, total int64, err error) {
+	limit := info.PageSize
+	offset := info.PageSize * (info.Page - 1)
+	nodes, total, err := dao.QueryNodeList(limit, offset)
+	return nodes, total, err
+}
+
+func (ns *NodeService) QueryNodeById(id int) (node dao.Node, err error) {
+	return dao.QueryNodeById(id)
+}
+
+func (ns *NodeService) QueryNodeByApproverId(approverId int) (nodes []dao.Node, err error) {
+	return dao.QueryNodeByApproverId(approverId)
+}
+
+func (ns *NodeService) CreateNode(node dao.Node) error {
+	return node.CreateNode()
+}
+
+func (ns *NodeService) UpdateNode(node dao.Node) error {
+	return node.UpdateNode()
+}
+
+func (ns *NodeService) DeleteNode(node dao.Node) error {
+	nodes, err := ns.QueryNodeByApproverId(int(node.ID))
+	if err != nil {
+		return err
+	}
+	if len(nodes) > 0 {
+		return fmt.Errorf("节点被使用")
+	}
+	return node.DeleteNode()
+}

server/service/workflow/process.go

@@ -0,0 +1,31 @@
+package workflow
+
+import (
+	"server/dao"
+	"server/model/common/request"
+)
+
+type ProcessService struct{}
+
+func (ps *ProcessService) QueryAllProcess() ([]dao.Process, error) {
+	return dao.QueryAllProcess()
+}
+
+func (ps *ProcessService) QueryProcessList(info request.PageInfo) (list interface{}, total int64, err error) {
+	limit := info.PageSize
+	offset := info.PageSize * (info.Page - 1)
+	processes, total, err := dao.QueryProcessList(limit, offset)
+	return processes, total, err
+}
+
+func (ps *ProcessService) CreateProcess(process dao.Process) error {
+	return process.CreateProcess()
+}
+
+func (ps *ProcessService) UpdateProcess(process dao.Process) error {
+	return process.UpdateProcess()
+}
+
+func (ps *ProcessService) DeleteProcess(process dao.Process) error {
+	return process.DeleteProcess()
+}

server/service/workflow/project_process.go

@@ -0,0 +1,34 @@
+package workflow
+
+import (
+	"server/dao"
+	"server/model/common/request"
+)
+
+type ProjectProcessService struct{}
+
+func (pps *ProjectProcessService) QueryProjectApplicantList(info request.SearchProjectProcess) (list interface{}, total int64, err error) {
+	limit := info.PageInfo.PageSize
+	offset := info.PageInfo.PageSize * (info.PageInfo.Page - 1)
+	projectProcesses, total, err := dao.QueryProjectApplicantList(limit, offset, info.UserId)
+	return projectProcesses, total, err
+}
+
+func (pps *ProjectProcessService) QueryProjectProcessList(info request.SearchProjectProcess) (list interface{}, total int64, err error) {
+	limit := info.PageInfo.PageSize
+	offset := info.PageInfo.PageSize * (info.PageInfo.Page - 1)
+	projectProcesses, total, err := dao.QueryProjectProcessList(limit, offset, info.UserId)
+	return projectProcesses, total, err
+}
+
+func (pps *ProjectProcessService) CreateProjectProcess(process dao.ProjectProcess) error {
+	return process.CreateProjectProcess()
+}
+
+func (pps *ProjectProcessService) UpdateProjectProcess(process dao.ProjectProcess) error {
+	return process.UpdateProjectProcess()
+}
+
+func (pps *ProjectProcessService) DeleteProjectProcess(process dao.ProjectProcess) error {
+	return process.DeleteProjectProcess()
+}

web/src/view/finance/financeAnalysis/financeAnalysis.vue

@@ -347,8 +347,8 @@ const projectList = (condition) => {
     if (res.code === 0) {
       const list = res.data.list
       projectTotal.value = res.data.total
-      console.log(list)
       listData.push(...list)
+      console.log(listData)
       symbol.changeCode(list[0].code)
       getMainMessage(list[0].code)
     }