Master Thesis - Collections as a data type of a process oriented language

This repository is part of a master thesis called "Collections as a data type of a process oriented language" by Bc. Adam Kuchcik.

This repository builds on top of the Netgrif Application Engine and expands it by adding a feature presenting a new data type called Collection which combines all previous data types that resemble a collection.

Resources

Petri net on the path src/main/resources/petriNets/collection_data_type.xml should contain all data fields that were tested in the thesis. This Petri net serves as a demo for the collection data type.

You can use this Petri net and test the collection data type yourself.

Abstract

SLOVAK UNIVERSITY OF TECHNOLOGY IN BRATISLAVA FACULTY OF ELECTRICAL ENGINEERING AND INFORMATION TECHNOLOGY

• Study Programme: Applied Informatics

• Author: Bc. Adam Kuchcik

• Master’s thesis: Collections as a data type of a process oriented language

• Supervisor: prof. RNDr. Gabriel Juhás, PhD.

• Place and year of submission: Bratislava 2023

The low-code languague Petriflow defines data variables and data types, which include data types that to a certain extent represent a collection of data. However, their limited implementation and lack of absraction limit their functionality. To solve this problem, in this thesis we're trying to create a new collection data type that merges the existing collection data types and increases their use cases. In the diploma thesis, we got acquainted with the Petriflow language, its data types, the interpreter of this language and the open-closed principle. We evaluated the existing data types of the collection and designed a flexible and scalable solution. We modified the Petriflow language interpreter to support the new data type with backend and frontend implementations. Collection data processing has been adapted to send and receive data between individual parts of the interpreter. We tested the functionality of the implementation and evaluated the benefits and expansion possibilities of the new data type.

Documentation that follows is the original documentation of the NAE application which includes all the necessary information for running NAE on your platform.

Netgrif Application Engine

Next-generation end-to-end low code platform.

Application Engine is a workflow management system fully supporting low-code language Petriflow. Application Engine (NAE for short) is based on Spring framework with fully complaint Petriflow language interpreter. NAE runs inside the Java Virtual Machine. It can be embedded into Java 11 project or used as a standalone process server. On top of the process server, NAE provides additional components to make integration to your project/environment seamless.

• Petriflow low-code language: http://petriflow.com
• Documentation: https://engine.netgrif.com

• Issue Tracker: GitHub issues
• Java docs: https://engine.netgrif.com/javadoc

• License: NETGRIF Community License

Components

Netgrif Application Engine (or NAE for short) consists of several key components:

• Workflow engine
  • Process executions - Process instance and task management
  • Actions and Events processing - Compiling and running action's code, handling events in processes
  • Roles management and permissions resolution - Permissions and restrictions resolving for processes
  • Search and filters - Indexing, querying and filter management.
• Authentication and authorization - User management and application-wide permissions
  • LDAP - Integration to authentication solution via LDAP protocol.
  • Organization structures - Managing organization structure for application users
• Business rules engine - Rules execution across whole application based on Drools
• Logging and auditing - Logging to text file and Event/Audit log generation to the main database
• Mail service - Mail client for sending and receiving emails
• Extension services
  • PDF generator - Generate PDF from process form / task
  • QR code generator - Generate QR code from process data

Requirements

The Application engine has some requirements for runtime environment. The following table is summary of requirements to run and use the engine:

Name	Version	Description	Recommendation
Java	11+	Java Development Kit	OpenJDK 11
Redis	5+	Key-value in-memory database used for user sessions and caching	Redis 6.2.6
MongoDB	4.4+	Main document store database	MongoDB 4.4.11
Elasticsearch	7.17+	Index database used for better application search	Elasticsearch 7.17.3

If you are planning on developing docker container based solution you can use our docker-compose configuration to run all necessary databases to develop with NAE.

Installation

Running as standalone

You can start using the NAE by its self and then upload your processes via API. You run the NAE from JAR (Java Archive) file or as docker container.

Running a JAR file

To run the engine from the jar file you can use a release package available from this repository. The latest release package you can download from here. Before you start you must generate own RSA key pair for session tokens, you can follow this guide.

To quickly start working with the engine just write the following commands to download, unzip, generate security keys and start:

$ wget -O nae.zip https://github.com/netgrif/application-engine/releases/latest
$ unzip nae.zip
$ cd nae
$ cd src/main/resources/certificates && openssl genrsa -out keypair.pem 4096 && openssl rsa -in keypair.pem -pubout -out public.crt && openssl pkcs8 -topk8 -inform PEM -outform DER -nocrypt -in keypair.pem -out private.der && cd ../../../..
$ java -jar nae.jar

Only generate security keys:

$ cd src/main/resources/certificates && openssl genrsa -out keypair.pem 4096 && openssl rsa -in keypair.pem -pubout -out public.crt && openssl pkcs8 -topk8 -inform PEM -outform DER -nocrypt -in keypair.pem -out private.der && cd ../../../..

By default, the engine assumes that all databases are running locally. If you are running required database on server or on different ports, you can pass these settings as arguments to NAE.

$ java -jar nae.jar --spring.data.mongodb.uri=mongodb://localhost:27017/nae --spring.data.elasticsearch.url=localhost --spring.session.redis.host=localhost

Running as Docker container

You can also use docker to run the engine from the official image on Docker hub.

$ docker pull netgrif/application-engine
$ docker run -d -p 8080:8080 netgrif/application-engine

As the engine connects by default to locally ran databases for more precise configuration we recommend to use Docker compose file or Kubernetes manifest to run whole stack all at once.

Embedding

The Application Engine can be used inside your java application as a java library. The engine is written in Spring framework, so you can seamlessly integrate it to your Spring Boot application. The engine can be linked as a Maven dependency:

<dependency>
    <groupId>com.netgrif</groupId>
    <artifactId>application-engine</artifactId>
</dependency>

Other projects

Application Builder

For creating processes in Petriflow language try our free Application Builder on https://builder.netgrif.com. You can start from scratch or import existing process in BPMN 2.0 and builder automatically converts it into Petriflow.

NCLI (Coming soon)

If you need help with setting up project or looking for tool to automate your developer work with NAE based applications, take a look on NCLI (Netgrif Command Line Interface).

Reporting issues

If you find a bug, let us know at Issue page. First, please read our Contribution guide

License

The software is licensed under NETGRIF Community license. You may be found this license at the LICENSE file in the repository.