hongze_mobile_admin/services/flow/flow.go

package flow

import (
	"errors"
	"hongze/hongze_mobile_admin/models/tables/admin"
	"hongze/hongze_mobile_admin/models/tables/approval_flow"
	"hongze/hongze_mobile_admin/models/tables/approval_flow_node"
	"hongze/hongze_mobile_admin/models/tables/contract_approval_record"
	"strings"
)

//获取审批工作流（基础）
func GetApprovalFlow(flowId int) (approvalFlow *approval_flow.ApprovalFlowItem, err error) {
	approvalFlow, err = approval_flow.GetByFlowItemId(flowId)
	if err != nil {
		err = errors.New("查询审批流程失败：Err:" + err.Error())
		return
	}
	approvalFlowNodeList, err := approval_flow_node.GetListByFlowId(approvalFlow.FlowId, approvalFlow.CurrVersion)
	if err != nil {
		err = errors.New("查询审批节点失败：Err:" + err.Error())
		return
	}
	for _, approvalFlowNode := range approvalFlowNodeList {
		userList, tmpErr := getAdminListByUserType(approvalFlowNode.UserType, approvalFlowNode.User, approvalFlow.ProductId)
		if tmpErr != nil {
			err = errors.New("获取审批人失败：Err:" + tmpErr.Error())
			return
		}
		for _, user := range userList {
			userInfo := approval_flow_node.User{
				AdminId:      user.AdminId,
				Name:         user.RealName,
				RoleTypeCode: user.RoleTypeCode,
				Mobile:       user.Mobile,
			}
			approvalFlowNode.UserList = append(approvalFlowNode.UserList, userInfo)
		}
	}
	approvalFlow.NodeList = approvalFlowNodeList

	return
}

//格式化数据返回
func FormatApprovalFlow(approvalFlow *approval_flow.ApprovalFlowItem) (list [][]contract_approval_record.ContractApprovalRecord, err error) {
	for _, node := range approvalFlow.NodeList {
		approvalRecordList := make([]contract_approval_record.ContractApprovalRecord, 0)

		for _, user := range node.UserList {
			approvalRecord := contract_approval_record.ContractApprovalRecord{
				Status:              "待审批",
				ApproveRoleTypeCode: user.RoleTypeCode,
				ApproveUserId:       user.AdminId,
				ApproveUserName:     user.Name,
				NodeId:              node.NodeId,
				NodeType:            node.NodeType,
				PrevNodeId:          node.PrevNodeId,
				NextNodeId:          node.NextNodeId,
				AuditType:           node.AuditType,
				CreateTime:          node.CreateTime,
			}
			approvalRecordList = append(approvalRecordList, approvalRecord)
		}
		list = append(list, approvalRecordList)
	}
	return
}

//获取审批人信息
func getAdminListByUserType(userType, user string, productId int) (adminList []*admin.Admin, err error) {
	switch userType {
	case "user":
		adminList, err = admin.GetAdminListByIds(user)
		return
	case "manager":
		roleTypeCode := ``
		if productId == 1 {
			roleTypeCode = `ficc_admin`
		} else if productId == 1 {
			roleTypeCode = `rai_admin`
		}
		if roleTypeCode == `` {
			err = errors.New("找不到对应的主管")
			return
		}
		adminList, err = admin.GetAdminListByRoleCode(roleTypeCode)
		return
	case "role": //角色类型
		roleSlice := strings.Split(user, ",")
		for _, roleTypeCode := range roleSlice {
			list, tmpErr := admin.GetAdminListByRoleCode(roleTypeCode)
			if tmpErr != nil {
				err = tmpErr
				return
			}
			adminList = append(adminList, list...)
		}
		return
	}
	err = errors.New("查找审批人信息异常")
	return
}

//获取审批单的审批流程
func GetNewApprovalFlow(contractApprovalId int) (flowNodeListResp [][]*contract_approval_record.ContractApprovalRecord, err error) {
	list, err := contract_approval_record.GetContractApprovalRecordListByContractApprovalId(contractApprovalId)
	nodeMap := make(map[int][]*contract_approval_record.ContractApprovalRecord)
	nodeIdList := make([]int, 0)
	for _, contractApprovalRecord := range list {
		if _, ok := nodeMap[contractApprovalRecord.NodeId]; ok {
			nodeMap[contractApprovalRecord.NodeId] = append(nodeMap[contractApprovalRecord.NodeId], contractApprovalRecord)
		} else {
			tmp := make([]*contract_approval_record.ContractApprovalRecord, 0)
			tmp = append(tmp, contractApprovalRecord)
			nodeMap[contractApprovalRecord.NodeId] = tmp
			nodeIdList = append(nodeIdList, contractApprovalRecord.NodeId)
		}
	}
	for _, nodeId := range nodeIdList {
		flowNodeListResp = append(flowNodeListResp, nodeMap[nodeId])
	}

	return
}