processmaker/nayra

Nayra is a BPMN workflow engine in PHP. Utilize it in your own projects to have your own complex workflow capabilities.

ProcessMaker Nayra

ProcessMaker Nayra is a package that provides base classes to implement a process execution engine. This includes patterns to implement activities, events and gateways.

How to execute a process

Load a BPMN definition

        $bpmnRepository = new BpmnDocument();
        $bpmnRepository->setEngine($this->engine);
        $bpmnRepository->setFactory($this->repository);
        $bpmnRepository->load('files/ParallelGateway.bpmn');

Get a reference to the process

        $process = $bpmnRepository->getProcess('ParallelGateway');

Create a data storage

        $dataStore = $this->repository->createDataStore();

Create a process instance

        $instance = $this->engine->createExecutionInstance($process, $dataStore);

Trigger the start event

        $start = $bpmnRepository->getStartEvent('StartEvent');
        $start->start($instance);

Execute tokens and run to the next state

        $this->engine->runToNextState();

One token arrives to the first task

        $firstTask = $bpmnRepository->getScriptTask('start');
        $token = $firstTask->getTokens($instance)->item(0);

Complete the first task

        $startActivity->complete($token);

Execute tokens and run to the next state

        $this->engine->runToNextState();

One token arrives to the second task and one to the third task

        $secondTask = $bpmnRepository->getScriptTask('ScriptTask_1');
        $token1 = $secondTask->getTokens($instance)->item(0);
        $thirdTask = $bpmnRepository->getScriptTask('ScriptTask_2');
        $token2 = $thirdTask->getTokens($instance)->item(0);

License

ProcessMaker Nayra is open-sourced software licensed under the Apache 2.0 license.

nayra's Issues

Implement BPMN Intermediate message Event

Fix EngineTrait to use the Repository to get an execution instance

Implement Xml Loader of BPMN files

As a developer, I would like to load a process definition from a BPMN file or string.

nayra vs Workflower

Hi,

I'm evaluating BPMN engines in PHP and I've found yours and Workflower. How exactly those 2 differentiate?

Can you provide some guidance how would I do a simple user interactive process like "reject"/"approve"?

Implement the the trait to allow load store of execution Instance/Token

As a developer I would like to have a base Trait to load and store Process Instances and Tokens in any persistent storage I use.

Remove the dependency with Laravel Events

Implement a Repository for Execution Instances

This Repository should be able to save and load the state and tokens for a process instance.

Implement Start Conditional Event

Implement the Activity Event classes

Rename the package ProcessMaker\Nayra\Bpmn\Model to ProcessMaker\Nayra\Bpmn\Models

Implement Call Activity for Sub Processes

Add a STATUS getter/setter for TokenInterface

Add a STATUS getter/setter for TokenInterface and change the use of $token->setProperty('STATUS', ...) to $token->setStatus(...);

Throw of Multiple Event Definitions

As a process designer, I would like that a throwing event was able to send multiple event definitions.

Implement Start Timer Event

Fix Engine and EventBus to use Laravel Dispatcher without implement EventBusInterface

Implement Start Signal Event

Implement End Signal Event

Events for Process Instance Created and Completed

Change Process event EVENT_PROCESS_COMPLETED to EVENT_PROCESS_INSTANCE_COMPLETED and implement the EVENT_PROCESS_INSTANCE_CREATED

Implement the BPMN signal event

The signal event allows sending broadcast messages. A signal has just one property: its name. All listeners of signals will receive it.

Implement the Script Task

As a developer I would like to have a base Trait to implement a Script Task class that will execute my business scripts.

Implement Start Message Event

Complete tests to improve code coverage of the Nayra/Bbmn/Model classes

Load processes from BPMN file

Change the Factory pattern to Repository pattern

Export BPMN file from a process definition.

Implement End Error Event

Encapsulate in a method the way an Transition calculate the tokens it consume

Since the different gateways have different ways to determinate which and how many tokens they consume, this implementation should be overridable by the bpmn element. The common behaviour should be consume one token per incoming flow.

Change the Engine implementation to use the instance repositories

Implement BPMN Participant element

Implement default final model classes for flow elements

As a developer, I would like to have ready to use classes to load and execute BPMN processes.

Implement default final repository classes for BPMN element. For:

Flow classes and repositories:
Process
Activity
Gateway
Event

Move the test classes from package ProcessMaker\Models to ProcessMaker\Tests\Models

Remove all Models and Repositories of the test directory

• Remove the models and repositories and adapt the current tests to the new factory and models implemented in Nayra/Bpmn/Model.
• If there are some classes in tests/Model that wern't moved yet, move them to the Nayra/Bpmn/Model namespace.

Complete the Activity states implementation

As a developer I want the activity instances (tokens) has this states: ACTIVE, FAILING, COMPLETED.

Implement Intermediate Catch Timer Event

Configure code coverage to circleci configuration

Create a InstanceRepository

Implement default final model classes for flow collaboration and other elements

As a developer, I would like to have ready to use classes to load and execute BPMN processes.

Implement default final repository classes for BPMN element. For:

Collaboration and other elements

• RootElements
• EventDefinitions
• ExecutionElements

Implement the Process Instance Events Completed and Created

As a developer I would like to receive the process instance event payloads as Event classes.

Implement the Parallel Gateway element

Parallel Gateway is used to synchronize multiple concurrent branches (merging behavior). On the
other hand, it is used to spawn new concurrent threads on parallel branches (branching behavior).

Operational Semantics
The Parallel Gateway consumes exactly one token from each incoming Sequence Flow and produces exactly one token at each outgoing Sequence Flow. If there are excess tokens at an incoming Sequence Flow, these tokens remain at this Sequence Flow after execution of the Gateway.

Exception Issues: The Parallel Gateway cannot throw any exception.

Fix the composer.json file

Currently the composer.json file has some wrong parameters like:
name - should be ProcessMaker/nayra
authors - do not add personal information
require - remove laravel dependencies

Implement End Message Event

Complete Activity Exception test

Implement the Lane and LaneSet

As a process designer I would like to add lanes to my diagram

An activity should be close after the outgoing token enters to the next element

Implemente Message Interfaces and Traits

BPM-9

Complete tests for the first commit of the Nayra engine

Implement concrete model classes for each BPMN element

As a developer I would like to have ready to use classes to load and execute BPMN processes.

Complete the execution instance reference by token

Implement the Exclusive Gateway element

As a BPM designer, I want to be able to create processes where a flow can be routed to just one outgoing flow following the definition of the Exclusive Gateway, as defined in the BPM standard

Implement End Terminate Event