goflow

package module
v0.0.0-...-6014147 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Jul 11, 2015 License: MIT Imports: 16 Imported by: 0

README

goflow

a pure golang workflow

license

MIT

Documentation

Index

Constants

View Source
const (
	DEFAULT_SEPARATOR   = "."                                    //默认分割符
	DEFAULT_KEY_ACTOR   = "s_actors"                             //指定的actors
	DEFAULT_START_ID    = "00000000-0000-0000-0000-000000000000" //start node
	ORDERNO_TIME_LAYOUT = "2006-01-02_15:04:05.000"              //OrderNo时间格式
	STD_TIME_LAYOUT     = "2006-01-02 15:04:05"                  //标准时间格式

)

特性的关键字

Variables

View Source
var (
	Cfg             *goconfig.ConfigFile
	RunMode         string
	DbDriver        string
	DbDriverConnstr string
	DbUsername      string
	DbPassword      string
	DbServer        string
	DbPort          int
	DbDatebase      string
	MaxIdleConns    int
	MaxOpenConns    int
)

Functions

func AddTaskActor

func AddTaskActor(taskId string, performType PERFORM_ORDER, actors ...string)

加任务角色

func AssignTask

func AssignTask(taskId string, actors ...string)

对指定的任务分配参与者。参与者可以为用户、部门、角色

func AutoExecuteTask

func AutoExecuteTask(tm *TaskModel, execution *Execution, tasks []*Task)

自动运行需要自动运行的任务

func CanRejected

func CanRejected(currentNode INodeModel, parentNode INodeModel) bool

能否驳回

func CompleteOrder

func CompleteOrder(id string)

完成Order

func CreateCCOrder

func CreateCCOrder(orderId string, creator string, actorIds ...string)

创建抄送

func CreateNewTask

func CreateNewTask(taskId string, taskType TASK_ORDER, actors ...string)

根据已有任务、任务类型、参与者创建新的任务,适用于转派,动态协办处理

func Delete

func Delete(inf interface{}, id interface{})

删除实体对象

func DeleteCCOrder

func DeleteCCOrder(orderId string, actorId string)

删除指定的抄送记录

func DeleteObj

func DeleteObj(inf interface{})

删除实体对象

func FindActiveNodes

func FindActiveNodes(node INodeModel) []string

查找分叉节点

func FindForkTaskNames

func FindForkTaskNames(node INodeModel) []string

递归查找分叉节点

func FormatTime

func FormatTime(t time.Time, layout string) string

格式化时间字符串

func GenerateNo

func GenerateNo() string

生成OrderNo

func GetSurrogate

func GetSurrogate(operator string, processName string) string

得到代理人

func GetTaskActors

func GetTaskActors(taskModel *TaskModel, execution *Execution) []string

得到任务的角色

func InitAccessByConfig

func InitAccessByConfig(cfg string)

初始化数据库ORM引擎

func InitAccessByXorm

func InitAccessByXorm(xorm *xorm.Engine)

初始化数据库ORM引擎

func InitConfig

func InitConfig(cfg string)

系统配置文件初始化(包含运行模式和数据库)

func IntToStr

func IntToStr(value int) string

整型转字符串

func Intercept

func Intercept(interceptors []IInterceptor, execution *Execution)

执行拦截器

func IsAllowed

func IsAllowed(task *Task, operator string) bool

是否被授权执行任务

func JsonToMap

func JsonToMap(v string) map[string]interface{}

json转map

func LoadXML

func LoadXML(xmlFile string) []byte

装载XML文件

func MapToJson

func MapToJson(v map[string]interface{}) string

map转json

func MergeActorHandle

func MergeActorHandle(tm *TaskModel, execution *Execution)

合并任务角色的处理

func MergeHandle

func MergeHandle(execution *Execution, activeNodes []string)

合并处理通用流程

func NewUUID

func NewUUID() string

生成UUID

func PanicIf

func PanicIf(err error, format string, v ...interface{})

error处理

func ProcessTime

func ProcessTime(args map[string]interface{}, timeParam string) time.Time

func RemoveTaskActor

func RemoveTaskActor(taskId string, actors ...string)

删除任务角色

func ResumeOrder

func ResumeOrder(id string)

唤醒Order

func Save

func Save(inf interface{}, id interface{})

保存实体对象

func SaveOrder

func SaveOrder(order *Order)

保存Order

func SaveTask

func SaveTask(task *Task, actors ...string)

保存任务

func StartSubProcessHandle

func StartSubProcessHandle(spm *SubProcessModel, execution *Execution) error

开始子流程处理

func StrToInt

func StrToInt(value string) int

字符串转整型

func StringsRemove

func StringsRemove(strings []string, start, end int) []string

删除Slice中的元素

func StringsRemoveAtIndex

func StringsRemoveAtIndex(strings []string, index int) []string

删除Slice中的元素

func TerminateOrder

func TerminateOrder(id string, operator string)

终止Order

func Update

func Update(inf interface{}, id interface{})

更新实体对象

func UpdateCCStatus

func UpdateCCStatus(orderId string, actorIds ...string)

更新抄送记录状态为已阅

Types

type BaseModel

type BaseModel struct {
	Name        string `xml:"name,attr"`        //节点名称
	DisplayName string `xml:"displayName,attr"` //节点显示名称
}

XML节点基本模型

func (*BaseModel) GetName

func (p *BaseModel) GetName() string

type CCOrder

type CCOrder struct {
	Id         string      `xorm:"varchar(36) pk notnull"` //主键ID
	OrderId    string      `xorm:"varchar(36) index"`      //流程实例ID
	ActorId    string      `xorm:"varchar(36)"`            //操作者ID
	Creator    string      `xorm:"varchar(36)"`            //流程实例创建者ID
	CreateTime time.Time   `xorm:"datetime"`               //流程实例创建时间
	FinishTime time.Time   `xorm:"datetime"`               //流程实例完成时间
	State      FLOW_STATUS `xorm:"tinyint"`                //流程实例状态
}

抄送实例表

func GetCCOrder

func GetCCOrder(orderId string, actorIds ...string) []*CCOrder

type DecisionModel

type DecisionModel struct {
	NodeModel
	Expr string `xml:"expr,attr"` //决策的条件表达式
}

XML决策节点

func (*DecisionModel) Exec

func (p *DecisionModel) Exec(execution *Execution)

执行

type EXEC_ROLE

type EXEC_ROLE string

执行任务的角色

const (
	ER_ADMIN   EXEC_ROLE = "ADMIN"   //管理员执行
	ER_AUTO    EXEC_ROLE = "AUTO"    //自动执行
	ER_ORDERNO EXEC_ROLE = "ORDERNO" //流程编号
)

type EndModel

type EndModel struct {
	NodeModel
}

XML的结束节点

func (*EndModel) Exec

func (p *EndModel) Exec(execution *Execution)

执行

type Engine

type Engine struct {
	ProcessService //流程定义业务类
}

GFLOW数据流引擎

func NewEngineByConfig

func NewEngineByConfig(cfg string) *Engine

新建引擎

func NewEngineByXorm

func NewEngineByXorm(orm *xorm.Engine) *Engine

新建引擎

func (*Engine) CreateFreeTask

func (p *Engine) CreateFreeTask(orderId string, operator string, args map[string]interface{}, model *TaskModel) []*Task

根据流程实例ID,操作人ID,参数列表按照节点模型model创建新的自由任务

func (*Engine) ExecuteAndJumpTask

func (p *Engine) ExecuteAndJumpTask(id string, operator string, args map[string]interface{}, nodeName string) []*Task

执行并且跳到某个任务

func (*Engine) ExecuteByProcess

func (p *Engine) ExecuteByProcess(process *Process, operator string, args map[string]interface{},
	parentId string, parentNodeName string) *Execution

执行流程

func (*Engine) ExecuteTask

func (p *Engine) ExecuteTask(id string, operator string, args map[string]interface{}) []*Task

执行并且跳到某个任务

func (*Engine) GetExecutionByTaskId

func (p *Engine) GetExecutionByTaskId(id string, operator string, args map[string]interface{}) *Execution

通过任务ID,执行任务

func (*Engine) StartInstanceByExecution

func (p *Engine) StartInstanceByExecution(execution *Execution) *Order

通过执行体Execution开始实例

func (*Engine) StartInstanceById

func (p *Engine) StartInstanceById(id string, operator string, args map[string]interface{}) *Order

通过流程ID开始实例

func (*Engine) StartInstanceByName

func (p *Engine) StartInstanceByName(name string, version int, operator string, args map[string]interface{}) *Order

通过流程NAME开始实例

func (*Engine) StartProcess

func (p *Engine) StartProcess(process *Process, operator string, args map[string]interface{}) *Order

开始流程

type Execution

type Execution struct {
	Engine         *Engine                //引擎
	Process        *Process               //流程定义对象
	Order          *Order                 //流程实例对象
	ParentOrder    *Order                 //父流程实例
	ParentNodeName string                 //父流程实例节点名称
	ChildOrderId   string                 //子流程实例节点名称
	Args           map[string]interface{} //执行参数
	Operator       string                 //操作人
	Task           *Task                  //任务
	Tasks          []*Task                //返回的任务列表
	IsMerged       bool                   //是否已合并,针对join节点的处理
}

流程执行体

type FLOW_STATUS

type FLOW_STATUS int

流程可用的开关,包含Process、Order、Task

const (
	FS_FINISH      FLOW_STATUS = iota //结束状态
	FS_ACTIVITY                       //活动状态
	FS_TERMINATION                    //终止状态
)

type ForkModel

type ForkModel struct {
	NodeModel
}

XML分叉节点

func (*ForkModel) Exec

func (p *ForkModel) Exec(execution *Execution)

执行

type HistoryOrder

type HistoryOrder struct {
	Id         string      `xorm:"varchar(36) pk notnull"`    //主键ID
	ProcessId  string      `xorm:"varchar(36) notnull index"` //流程定义ID
	Creator    string      `xorm:"varchar(36)"`               //流程实例创建者ID
	CreateTime time.Time   `xorm:"datetime notnull"`          //流程实例创建时间
	ParentId   string      `xorm:"varchar(36) index"`         //流程实例为子流程时,该字段标识父流程实例ID
	ExpireTime time.Time   `xorm:"datetime"`                  //流程实例期望完成时间
	Priority   int         `xorm:"tinyint"`                   //流程实例优先级
	OrderNo    string      `xorm:"varchar(100) index"`        //流程实例编号
	Variable   string      `xorm:"varchar(2000)"`             //流程实例附属变量
	OrderState FLOW_STATUS `xorm:"tinyint notnull"`           //流程实例状态
	FinishTime time.Time   `xorm:"datetime"`                  //完成时间
}

历史流程实例实体类

func (*HistoryOrder) DataByOrder

func (p *HistoryOrder) DataByOrder(order *Order)

从Order对象获取数据构件HistoryOrder

func (*HistoryOrder) GetHistoryOrderById

func (p *HistoryOrder) GetHistoryOrderById(id string) bool

根据ID得到HistoryOrder

func (*HistoryOrder) Undo

func (p *HistoryOrder) Undo() *Order

通过HistoryOrder生成Order

type HistoryTask

type HistoryTask struct {
	Id           string        `xorm:"varchar(36) pk notnull"`     //主键ID
	OrderId      string        `xorm:"varchar(36) notnull index"`  //流程实例ID
	TaskName     string        `xorm:"varchar(100) notnull index"` //任务名称
	DisplayName  string        `xorm:"varchar(200) notnull"`       //任务显示名称
	PerformType  PERFORM_ORDER `xorm:"tinyint"`                    //任务参与方式
	TaskType     TASK_ORDER    `xorm:"tinyint notnull"`            //任务类型
	Operator     string        `xorm:"varchar(36)"`                //任务处理者ID
	CreateTime   time.Time     `xorm:"datetime notnull"`           //任务创建时间
	FinishTime   time.Time     `xorm:"datetime"`                   //任务完成时间
	ExpireTime   time.Time     `xorm:"datetime"`                   //期望任务完成时间
	Action       string        `xorm:"varchar(200)"`               //任务关联的Action(WEB为表单URL)
	ParentTaskId string        `xorm:"varchar(36) index"`          //父任务ID
	Variable     string        `xorm:"varchar(2000)"`              //任务附属变量(json存储)
	TaskState    FLOW_STATUS   `xorm:"tinyint notnull"`            //任务状态
}

任务实体类

func (*HistoryTask) GetHistoryTaskById

func (p *HistoryTask) GetHistoryTaskById(id string) bool

根据ID得到HistoryTask

func (*HistoryTask) Undo

func (p *HistoryTask) Undo() *Task

通过HistoryTask生成Task

type HistoryTaskActor

type HistoryTaskActor struct {
	Id      string `xorm:"varchar(36) pk notnull"`    //主键ID
	TaskId  string `xorm:"varchar(36) notnull index"` //任务ID
	ActorId string `xorm:"varchar(36) notnull"`       //参与者ID
}

历史任务参与者

type IInterceptor

type IInterceptor interface {
	GetName() string //Unique
	Intercept(execution *Execution)
	Clone() IInterceptor
}

拦截器需要实现的接口

type INodeModel

type INodeModel interface {
	GetName() string
	Exec(execution *Execution)
	Execute(execution *Execution)
	GetInputs() []*TransitionModel
	GetOutputs() []*TransitionModel
	AddInputs(tm ...*TransitionModel)
	BuildInterceptors(processService *ProcessService)
}

节点模型需要实现的接口

type JoinModel

type JoinModel struct {
	NodeModel
}

XML合并节点

func (*JoinModel) Exec

func (p *JoinModel) Exec(execution *Execution)

执行

func (*JoinModel) MergeBranchHandle

func (p *JoinModel) MergeBranchHandle(execution *Execution)

合并分叉节点

type NodeModel

type NodeModel struct {
	INodeModel
	BaseModel
	Inputs                  []*TransitionModel `xml:"-"`                     //输入变迁集合
	Outputs                 []*TransitionModel `xml:"transition"`            //输出变迁集合
	PrevInterceptorsSetting string             `xml:"prevInterceptors,attr"` //局部前置拦截器
	PostInterceptorsSetting string             `xml:"postInterceptors,attr"` //局部后置拦截器
	PrevInterceptors        []IInterceptor     `xml:"-"`                     //局部前置拦截器对象
	PostInterceptors        []IInterceptor     `xml:"-"`                     //局部后置拦截器对象
}

XML节点通用信息

func (*NodeModel) AddInputs

func (p *NodeModel) AddInputs(tm ...*TransitionModel)

func (*NodeModel) BuildInterceptors

func (p *NodeModel) BuildInterceptors(processService *ProcessService)

建立拦截器

func (*NodeModel) Execute

func (p *NodeModel) Execute(execution *Execution)

执行

func (*NodeModel) GetInputs

func (p *NodeModel) GetInputs() []*TransitionModel

得到输入变迁

func (*NodeModel) GetName

func (p *NodeModel) GetName() string

func (*NodeModel) GetOutputs

func (p *NodeModel) GetOutputs() []*TransitionModel

得到输出变迁

func (*NodeModel) PostIntercept

func (p *NodeModel) PostIntercept(execution *Execution)

执行拦截器

func (*NodeModel) PrevIntercept

func (p *NodeModel) PrevIntercept(execution *Execution)

执行拦截器

func (*NodeModel) RunOutTransition

func (p *NodeModel) RunOutTransition(execution *Execution)

运行变迁

type Order

type Order struct {
	Id             string    `xorm:"varchar(36) pk notnull"`    //主键ID
	Version        int       `xorm:"tinyint"`                   //版本
	ProcessId      string    `xorm:"varchar(36) notnull index"` //流程定义ID
	Creator        string    `xorm:"varchar(36)"`               //流程实例创建者ID
	CreateTime     time.Time `xorm:"datetime notnull"`          //流程实例创建时间
	ParentId       string    `xorm:"varchar(36) index"`         //流程实例为子流程时,该字段标识父流程实例ID
	ParentNodeName string    `xorm:"varchar(100)"`              //流程实例为子流程时,该字段标识父流程哪个节点模型启动的子流程
	ExpireTime     time.Time `xorm:"datetime"`                  //流程实例期望完成时间
	LastUpdateTime time.Time `xorm:"datetime"`                  //流程实例上一次更新时间
	LastUpdator    string    `xorm:"varchar(36)"`               //流程实例上一次更新人员ID
	Priority       int       `xorm:"tinyint"`                   //流程实例优先级
	OrderNo        string    `xorm:"varchar(100) index"`        //流程实例编号
	Variable       string    `xorm:"varchar(3000)"`             //流程实例附属变量
}

流程工作单实体类(一般称为流程实例)

func CreateOrder

func CreateOrder(process *Process, operator string, args map[string]interface{},
	parentId string, parentNodeName string) *Order

创建Order

func GetActiveOrdersSQL

func GetActiveOrdersSQL(querystring string, args ...interface{}) []*Order

得到活动的Order(通过SQL)

func (*Order) GetOrderById

func (p *Order) GetOrderById(id string) bool

根据ID得到Order

type PERFORM_ORDER

type PERFORM_ORDER int

任务参与方式

const (
	PO_ANY PERFORM_ORDER = iota //普通任务,即:任何一个参与者处理完即执行下一步
	PO_ALL                      //会签任务,即:所有参与者都完成,才可执行下一步
)

func ProcessPerformType

func ProcessPerformType(performType PERFORM_TYPE) PERFORM_ORDER

PerformType转换

type PERFORM_TYPE

type PERFORM_TYPE string

任务参与方式

const (
	PT_ANY PERFORM_TYPE = "ANY" //普通任务,即:任何一个参与者处理完即执行下一步
	PT_ALL PERFORM_TYPE = "ALL" //会签任务,即:所有参与者都完成,才可执行下一步
)

type Process

type Process struct {
	Id             string        `xorm:"varchar(36) pk notnull"` //主键ID
	Version        int           `xorm:"tinyint"`                //版本
	Name           string        `xorm:"varchar(100) index"`     //流程定义名称
	DisplayName    string        `xorm:"varchar(200)"`           //流程定义显示名称
	InstanceAction string        `xorm:"varchar(200)"`           //当前流程的实例Action,(Web为URL,一般为流程第一步的URL;APP需要自定义),该字段可以直接打开流程申请的表单
	State          FLOW_STATUS   `xorm:"tinyint"`                //状态
	CreateTime     time.Time     `xorm:"datetime"`               //创建时间
	Creator        string        `xorm:"varchar(36)"`            //创建人
	Content        string        `xorm:"text"`                   //流程定义XML
	Model          *ProcessModel `xorm:"-"`                      //Model对象
}

流程定义实体类

func GetLatestProcess

func GetLatestProcess(name string) *Process

得到最新的Process

func (*Process) GetProcess

func (p *Process) GetProcess() bool

根据Process本身条件得到Process

func (*Process) GetProcessById

func (p *Process) GetProcessById(id string) bool

根据ID得到Process

func (*Process) SetModel

func (p *Process) SetModel(model *ProcessModel)

设定Model对象

type ProcessModel

type ProcessModel struct {
	BaseModel
	StartNodes       []*StartModel      `xml:"start"`               //开始节点
	EndModels        []*EndModel        `xml:"end"`                 //结束阶段
	TaskModels       []*TaskModel       `xml:"task"`                //任务节点
	DecisionModels   []*DecisionModel   `xml:"decision"`            //决策节点
	ForkModels       []*ForkModel       `xml:"fork"`                //分支节点
	JoinModels       []*JoinModel       `xml:"join"`                //合并节点
	SubProcessModels []*SubProcessModel `xml:"subprocess"`          //子流程节点
	InstanceAction   string             `xml:"instanceAction,attr"` //流程实例启动Action(web为url)
	ExpireTime       string             `xml:"expireTime,attr"`     //期望完成时间
	Models           []INodeModel       `xml:"-"`                   //上面所有Node节点(Start\End\Task\Decision\Fork\Join\SubProcess)的集合
}

XML定义process节点元素

func (*ProcessModel) BuildRelationship

func (p *ProcessModel) BuildRelationship(content []byte, processService *ProcessService)

func (*ProcessModel) ContainsSubProcessNodeNames

func (p *ProcessModel) ContainsSubProcessNodeNames(nodeNames ...string) bool

根据任务名,是否包含子流程

func (*ProcessModel) ContainsTaskNodeNames

func (p *ProcessModel) ContainsTaskNodeNames(nodeNames ...string) bool

根据任务名,是否包含任务

func (*ProcessModel) GetNode

func (p *ProcessModel) GetNode(name string) INodeModel

根据名称得到节点

func (*ProcessModel) GetStart

func (p *ProcessModel) GetStart() *StartModel

得到开始节点

type ProcessService

type ProcessService struct {
	ProcessCache           map[string]*Process     //Process缓存,KEY为[名称.版本]
	NameCache              map[string]string       //ProcessName缓存,KEY为ID
	InnerInterceptorCache  map[string]IInterceptor //内置拦截器
	CustomInterceptorCache map[string]IInterceptor //自定义拦截器
}

流程服务

func (*ProcessService) Cache

func (p *ProcessService) Cache(process *Process)

缓存Process

func (*ProcessService) Deploy

func (p *ProcessService) Deploy(input []byte, creator string) string

部署Process

func (*ProcessService) GetCustomInterceptor

func (p *ProcessService) GetCustomInterceptor(name string) IInterceptor

获取自定义缓存拦截器

func (*ProcessService) GetInnerInterceptor

func (p *ProcessService) GetInnerInterceptor(name string) IInterceptor

获取缓存拦截器

func (*ProcessService) GetProcessById

func (p *ProcessService) GetProcessById(id string) *Process

根据ID得到Process

func (*ProcessService) GetProcessByVersion

func (p *ProcessService) GetProcessByVersion(name string, version int) *Process

根据名称、版本得到Process

func (*ProcessService) InitProcessService

func (p *ProcessService) InitProcessService()

初始化服务对象和加入内置拦截器

func (*ProcessService) ReDeploy

func (p *ProcessService) ReDeploy(id string, input []byte)

重新部署Process

func (*ProcessService) SetCustomInterceptor

func (p *ProcessService) SetCustomInterceptor(interceptor IInterceptor)

使用自定义拦截器缓存

func (*ProcessService) SetInnerInterceptor

func (p *ProcessService) SetInnerInterceptor(interceptor IInterceptor)

使用拦截器缓存

func (*ProcessService) UnDeploy

func (p *ProcessService) UnDeploy(id string)

卸载部署

type SURROGATE_STATUS

type SURROGATE_STATUS int

委托代理的状态

const (
	SS_DISABLE SURROGATE_STATUS = iota //不可用
	SS_ENABLE                          //可用
)

type StartModel

type StartModel struct {
	NodeModel
}

XML开始节点元素

func (*StartModel) Exec

func (p *StartModel) Exec(execution *Execution)

执行

type SubProcessModel

type SubProcessModel struct {
	WorkModel
	ProcessName string `xml:"processName,attr"` //子流程名称
	Version     int    `xml:"version,attr"`     //子流程版本号
}

流程定义实体类

func (*SubProcessModel) Exec

func (p *SubProcessModel) Exec(execution *Execution)

执行

type Surrogate

type Surrogate struct {
	Id          string           `xorm:"varchar(36) pk notnull"`    //主键ID
	ProcessName string           `xorm:"varchar(36) notnull"`       //流程名称
	Operator    string           `xorm:"varchar(36) notnull index"` //授权人
	Surrogate   string           `xorm:"varchar(36)"`               //代理人
	OpTime      time.Time        `xorm:"datetime"`                  //操作时间
	StartTime   time.Time        `xorm:"datetime"`                  //开始时间
	EndTime     time.Time        `xorm:"datetime"`                  //结束时间
	State       SURROGATE_STATUS `xorm:"tinyint"`                   //状态
}

委托代理

func GetSurrogateSQL

func GetSurrogateSQL(querystring string, args ...interface{}) []*Surrogate

得到代理人(通过SQL)

type SurrogateInterceptor

type SurrogateInterceptor struct {
}

委托代理拦截器

func (*SurrogateInterceptor) Clone

func (*SurrogateInterceptor) GetName

func (p *SurrogateInterceptor) GetName() string

func (*SurrogateInterceptor) Intercept

func (p *SurrogateInterceptor) Intercept(execution *Execution)

type TASK_ORDER

type TASK_ORDER int

任务类型

const (
	TO_MAJOR  TASK_ORDER = iota //主办任务
	TO_ASSIST                   //协办任务
)

func ProcessTaskType

func ProcessTaskType(taskType TASK_TYPE) TASK_ORDER

TaskType转换

type TASK_TYPE

type TASK_TYPE string

任务类型

const (
	TT_MAJOR  TASK_TYPE = "MAJOR"  //主办任务
	TT_ASSIST TASK_TYPE = "ASSIST" //协办任务
)

type Task

type Task struct {
	Id           string        `xorm:"varchar(36) pk notnull"`     //主键ID
	Version      int           `xorm:"tinyint"`                    //版本
	OrderId      string        `xorm:"varchar(36) notnull index"`  //流程实例ID
	TaskName     string        `xorm:"varchar(100) notnull index"` //任务名称
	DisplayName  string        `xorm:"varchar(200) notnull"`       //任务显示名称
	PerformType  PERFORM_ORDER `xorm:"tinyint"`                    //任务参与方式
	TaskType     TASK_ORDER    `xorm:"tinyint notnull"`            //任务类型
	Operator     string        `xorm:"varchar(36)"`                //任务处理者ID
	CreateTime   time.Time     `xorm:"datetime"`                   //任务创建时间
	FinishTime   time.Time     `xorm:"datetime"`                   //任务完成时间
	ExpireTime   time.Time     `xorm:"datetime"`                   //期望任务完成时间
	RemindTime   time.Time     `xorm:"datetime"`                   //提醒时间
	Action       string        `xorm:"varchar(200)"`               //任务关联的Action(WEB为表单URL)
	ParentTaskId string        `xorm:"varchar(36) index"`          //父任务ID
	Variable     string        `xorm:"varchar(2000)"`              //任务附属变量(json存储)
	Model        *TaskModel    `xorm:"-"`                          //Model对象
}

任务实体类

func CompleteTask

func CompleteTask(taskId string, operator string, args map[string]interface{}) *Task

完成任务

func CreateTask

func CreateTask(taskModel *TaskModel, execution *Execution) []*Task

创建task,并根据model类型决定是否分配参与者

func CreateTaskHandle

func CreateTaskHandle(tm *TaskModel, execution *Execution) []*Task

根据任务节点创建任务对象

func GetActiveTasksByOrderId

func GetActiveTasksByOrderId(orderId string) []*Task

根据OrderID得到活动流程

func GetActiveTasksSQL

func GetActiveTasksSQL(querystring string, args ...interface{}) ([]*Task, error)

得到活动的任务(通过SQL)

func GetNextAllActiveTasks

func GetNextAllActiveTasks(orderId string, taskName string, parentTaskId string) []*Task

得到下一个ALL类型的任务

func GetNextAnyActiveTasks

func GetNextAnyActiveTasks(parentTaskId string) []*Task

得到下一个ANY类型的任务

func RejectTask

func RejectTask(processModel *ProcessModel, currTask *Task) *Task

驳回任务

func TakeTask

func TakeTask(taskId string, operator string) *Task

结束并且提取任务

func WithdrawTask

func WithdrawTask(taskId string, operator string) *Task

撤销任务

func (*Task) GetActiveTasks

func (p *Task) GetActiveTasks() []*Task

得到活动任务

func (*Task) GetActiveTasksByOrderId

func (p *Task) GetActiveTasksByOrderId(orderId string) []*Task

根据OrderID得到活动任务

func (*Task) GetTaskActors

func (p *Task) GetTaskActors() []*TaskActor

得到任务角色

func (*Task) GetTaskById

func (p *Task) GetTaskById(id string) bool

根据ID得到任务

type TaskActor

type TaskActor struct {
	Id      string `xorm:"varchar(36) pk notnull"`                        //主键ID
	TaskId  string `xorm:"varchar(36) notnull index(IDX_TASKACTOR_TASK)"` //任务ID
	ActorId string `xorm:"varchar(36) notnull"`                           //参与者ID
}

任务参与者

func GetTaskActorsByTaskId

func GetTaskActorsByTaskId(taskId string) []*TaskActor

通过任务ID,得到任务角色

type TaskModel

type TaskModel struct {
	WorkModel
	Assignee    string       `xml:"assignee,attr"`    //参与者变量名称
	PerformType PERFORM_TYPE `xml:"performType,attr"` //参与方式
	TaskType    TASK_TYPE    `xml:"taskType,attr"`    //任务类型
	AutoExecute bool         `xml:"autoExecute,attr"` //是否自动执行
	ExpireTime  string       `xml:"expireTime,attr"`  //期望完成时间
}

XML流程定义的任务节点

func (*TaskModel) Exec

func (p *TaskModel) Exec(execution *Execution)

执行

type TransitionModel

type TransitionModel struct {
	BaseModel
	Source  INodeModel `xml:"-"`         //变迁的源节点引用
	Target  INodeModel `xml:"-"`         //变迁的目标节点引用
	To      string     `xml:"to,attr"`   //变迁的目的节点
	Expr    string     `xml:"expr,attr"` //变迁的条件表达式,用于decision
	Enabled bool       `xml:"-"`         //当前变迁路径是否可用
}

XML变迁节点元素

func (*TransitionModel) Execute

func (p *TransitionModel) Execute(execution *Execution)

执行

type WorkModel

type WorkModel struct {
	NodeModel
	Action string `xml:"action,attr"`
}

工作节点元素,目前是Task和SubProcess的基础,同时也是业务数据的绑定点

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL