基于petri网用golang写一个可配置的工单流程

下面是一个基于Petri网的可配置工单流程示例，使用Go语言编写：

package main

import (
	"fmt"
)

// 工单状态枚举
type WorkOrderStatus int

const (
	Created WorkOrderStatus = iota
	Assigned
	InProgress
	Completed
	Cancelled
)

// 工单结构体
type WorkOrder struct {
	ID     string
	Status WorkOrderStatus
}

// Petri网结构体
type PetriNet struct {
	Transitions []Transition
}

// 迁移结构体
type Transition struct {
	Name      string
	From      []WorkOrderStatus
	To        WorkOrderStatus
	Condition func(order WorkOrder) bool
	Action    func(order *WorkOrder)
}

// 创建工单迁移条件函数
func canCreate(order WorkOrder) bool {
	return order.Status == Created || order.Status == Cancelled
}

// 创建工单迁移动作函数
func create(order *WorkOrder) {
	order.Status = Created
	fmt.Println("工单创建成功")
}

// 分配工单迁移条件函数
func canAssign(order WorkOrder) bool {
	return order.Status == Created || order.Status == Cancelled
}

// 分配工单迁移动作函数
func assign(order *WorkOrder) {
	order.Status = Assigned
	fmt.Println("工单分配成功")
}

// 开始工单迁移条件函数
func canStart(order WorkOrder) bool {
	return order.Status == Assigned
}

// 开始工单迁移动作函数
func start(order *WorkOrder) {
	order.Status = InProgress
	fmt.Println("工单开始处理")
}

// 完成工单迁移条件函数
func canComplete(order WorkOrder) bool {
	return order.Status == InProgress
}

// 完成工单迁移动作函数
func complete(order *WorkOrder) {
	order.Status = Completed
	fmt.Println("工单处理完成")
}

// 取消工单迁移条件函数
func canCancel(order WorkOrder) bool {
	return order.Status != Completed && order.Status != Cancelled
}

// 取消工单迁移动作函数
func cancel(order *WorkOrder) {
	order.Status = Cancelled
	fmt.Println("工单已取消")
}

func main() {
	// 创建Petri网
	petriNet := PetriNet{
		Transitions: []Transition{
			{
				Name:      "创建工单",
				From:      []WorkOrderStatus{Created, Cancelled},
				To:        Created,
				Condition: canCreate,
				Action:    create,
			},
			{
				Name:      "分配工单",
				From:      []WorkOrderStatus{Created, Cancelled},
				To:        Assigned,
				Condition: canAssign,
				Action:    assign,
			},
			{
				Name:      "开始工单",
				From:      []WorkOrderStatus{Assigned},
				To:        InProgress,
				Condition: canStart,
				Action:    start,
			},
			{
				Name:      "完成工单",
				From:      []WorkOrderStatus{InProgress},
				To:        Completed,
				Condition: canComplete,
				Action:    complete,
			},
			{
				Name:      "取消工单",
				From:      []WorkOrderStatus{Created, Assigned, InProgress},
				To:        Cancelled,
				Condition: canCancel,
				Action:    cancel,
			},
		},
	}

	// 创建一个工单
	order := WorkOrder{
		ID:     "123",
		Status: Created,
	}

	// 尝试执行迁移
	for _, transition := range petriNet.Transitions {
		if containsStatus(transition.From, order.Status) && transition.Condition(order) {
			transition.Action(&order)
			break
		}
	}

	fmt.Printf("当前工单状态：%v\n", order.Status)
}

// 检查状态是否包含在切片中
func containsStatus(s []WorkOrderStatus, status WorkOrderStatus) bool {
	for _, v := range s {
		if v == status {
			return true
		}
	}
	return false
}

这个示例中，我们定义了一个`WorkOrder`结构体表示工单，通过`WorkOrderStatus`枚举定义了工单的不同状态。`PetriNet`结构体表示Petri网，其中包含了一组迁移`Transition`的定义。每个迁移都具有名称、起始状态、目标状态、迁移条件和迁移动作。在`main`函数中，我们创建了一个示例工单，并尝试执行可行的迁移。

请注意，这只是一个简单的示例，你可以根据具体需求扩展和修改Petri网的定义、迁移条件和迁移动作。