A sub-flowchart makes it possible to use a flowchart in a flowchart. When the sub-flowchart node in a flowchart is reached, the flowchart that is defined as sub-flowchart will start. Any flowchart can be used as a sub-flowchart. This allows you to create and use flowcharts as reusable functions that can be used in multiple other flowcharts.

When you drag and drop a flowchart node from the toolbar to the canvas, WEM shows a popup window that allowes you to select an existing flowchart to be added as a sub-flowchart. It is also possible to drag and drop a flowchart directly from the flowchart tab to the canvas.

Properties

A sub-flowchart node has no properties. The property panel on the right does provide some information on the name of the flowchart and which exits it contains.

Sub-flowcharts can have multiple exits. Every End node in a (sub-)flowchart is also an exit of that (sub-)flowchart.

The user interaction node is used when there is an interaction with the user. These nodes translate into forms or pages where a wide range of user interaction components can be used (forms, lists, buttons, images, charts, etc.).

Properties

The properties are accessed by selecting the node. The properties of the selected node are shown in the properties pane on the right hand side of the screen.

The Edit template button at the bottom of the properties form works the same as double-clicking the node: it opens the user interaction template editor.

User Interaction Node Editor

The editor is where you create the form / interaction that is needed to communicate with users of the application. This editor is also referred to as the "template editor". This template editor has to many features to explain in this chapter. Therefore a seperate section in this documentation is dedicated to the template editor.

The assignment node is used to assign a value to an item, like a data field, or an input field of a webservice. When the flowchart reaches the assignment node, that value will be set.

Starting from June 27 2022, the Assignment Node can be used to make assignments to multiple fields. This allows you to make multiple assignment very fast and easy and your Flowchart less cramped with all the assignment nodes when you need to update all fields from a list (for example).

When the node is added to the flowchart, the following popup appears:

From this popup you select the (writable) fields for which a value needs to be assigned and click the ok button.

It is also possible to add an Assignment Node to the canvas by dragging one or more (writable) fields from the Data Model to the canvas and selection the "Assignment" option.

Properties

When the assignment node on the canvas is selected the properties pane becomes visible on the right side of the screen. Through the assignment node properties pane a value can be assigned. Assigning a field from the Data Model can be done by selecting the "Advanced" action and dragging the required field in the expression editor. There is also an easier way that works by dragging the field directly from the Project resources pane and dropping it on the Action dropdown. This will change the Action to Advanced and sets the Expression to the dropped Field (its technical name).

The properties pane consist of the following elements:

Multi-Assignment Overlay

When multiple fields are selected (or added later) to the Assignment node, each field gets its own Assignment Action in this overlay. The overlay is accessible via the button [Edit Assignments] in the property pane or by double-clicking on the Assignment Node (when it contains multiple assignments). The actions and operands are the same as per single assignment node, specific to each fields data type.

Order

The order in which these assignments are displayed is important! It reflects also the order in which the assignments are executed. So you can actually assign a value to a field which then can be used in the assignment expressions in next fields. Use the buttons Move up and Move down to change the order of assignments. The assignment node itself cannot validate the order - you need to make sure the order is correct.

Actions

The list of actions that can be selected in the dropdown depends on which type of field is assigned. Almost all actions are very easy to understand based on the action name. In the overview below only the most common and most used are mentioned or those that could use some explanation. Add assignment nodes for different field types to the canvas to see all the possibilities.

When dragging and dropping a field to the Operand column the Action of that row is changed to the Advanced... option even when there is no input field shown. Fields that are non writable will be showing a red box in the drop-zone.

The clear session node is used to delete the current session and all related states (temporary data, flowchart stack, view state, comet listeners, et cetera). When a session is cleared, it will redirect you to the home page where it will create a new empty session. You can also specify another navigation item to return to.

The clear session node is an important safety measure that should, for example, be used in a log-out flowchart. This will make the logout permanent and prevents someone from returning to a logged in session by using the browsers back button.

The end node signals the end of the flowchart. When the end node is reached, the application will return to the spot where the current flowchart was started. Usually this means an interaction node that contains a button that started the flowchart or it continues in the previous flowchart.

Most flowcharts will contain 1 end node but it is not required. A flowchart can end in an interaction node with no exits rendering an end node not necessary. A flowchart can also contain multiple end nodes. A flowchart that does not end in an interaction node or a End node will produce an error.

Properties

The properties pane of the end node contains only 1 field: the name of the node. The default name is ‘End’. Usually the default name is sufficient but it can be changed if needed. This is especially usefull if multiple end nodes in one flowchart are used.

Multiple end nodes

In the example below 2 End nodes are added to the flowchart. When this flowchart is triggered from an interaction node it doesn't matter which End node is reached. In both scenarios it will return to the interaction node. If this flowchart is used as a sub-flowchart in another flowchart it will have 2 possible exits. 1 called "Save" and 1 called "Cancel"

When the flowchart reaches the navigation node, the application will open the specified navigation point and continue from there.

There are no exits and there is only one property: the Name. The name is the specified Navigation Point and cannot be changed in the flowchart. To learn more about Navigation Points, read the specific article on Navigation.

Important to keep in mind for the security of your applications is that navigation nodes bypass a navigation items visible when property. A decision node with the same expression as the navigation point can be used to reinstate the pages access protection.

The Flowcharts area of the WEM Modeler is where you model the way your application should work. Here you define the workflows, processes and all other functionality that make up your application. This also includes the use of user interaction screens (the screens or pages that are the application to its users).

The first flowcharts

When you look at the flowcharts of a new project, you will always find the default Home flowchart. This is the starting point for your project. When you create a new flowchart, you can choose between two types of flowcharts:

1. Regular flowchart: These are the flowcharts that can include user interaction (forms, pages, overlays, etc.). Most of the flowcharts are regular flowcharts.

2. Action flowchart: When a flowchart is needed that does not require any user interaction (e.g. a calculation, some background process that needs to run, etc.), you use an action flowchart. If your action flowchart contains sub-flowcharts there can not be any user interaction in one of the sub-flowcharts. In some situations, for example exposing webservice functionality, you can ONLY use action flowcharts. Action flowcharts can be distinguised from regular flowcharts by the lightning bolt in the icon.

Flowcharts can be organized in folders. When you have a small application with just a few flowcharts this is probably not necessary. But when you have an application that consists of hundreds (or even thousands) of flowcharts, it is important to have a structured list of folders to organize flowcharts. The way you want to organize flowcharts is up to you, there are no restrictions on the WEM Modeler side. Below is an example of flowcharts that have been organized in multiple folders.

Creating Flowcharts

When you select a flowchart or map you can see three dots appear. When you click the dots or right click a flowchart or folder the context menu appears.

When you open the context menu on a folder you will get the menu in the left picture. Here you can choose to make a new flowchart or a new folder to be placed in the selected folder.

On the right you see the menu when a flowchart is selected. From there you can open flowcharts, Open a preview of just one flowchart or copy a complete flowchart inside your project. It is not possible to copy flowcharts to other projects.

Both of them give you the option to rename your flowchart, delete it or find its usages. Renaming it will change the name in your whole project without breaking its functions.

The Find usages option is a useful tool to quickly see where a certain flowchart is used.

Flowchart Editor

When you open a flowchart, you see the canvas on which you will draw the actual workflow. It contains a toolbar (top), the Nodes-toolbar (left) and the Properties and Exits pane on the right (when a node is selected).

Working in the editor mainly consists of drag-and-drop actions with nodes and exits or arrows. Nodes can be selected from the Nodes-toolbar and dragged onto the editor pane. Nodes are connected with exits or arrows by either dragging arrows from one node to the other when you press and hold the ctrl-key, or from the edge of a node to the other without the ctrl-key. What these nodes and exits represent will be addressed later in this section.

Moving on the flowchart editor pane can be done in several ways. Zooming in and out can be done via the buttons in the toolbar at the top of the editor, or through scrolling with your mouse or track-pad. Zooming focus is determined by the location of the mouse on the editor pane. Furthermore, you can move the pane with drag-and-drop when you click and hold the space bar. This allows you to move around your flowchart without zooming.

How to use flowcharts

Flowcharts are the heart of your applications. With flowcharts you model the way your application works:

• Model your business process(es)

• Model the flow of your application

• Create the User Interaction (forms, pages, overlays)

• Integrate with external systems

• Etc.

Creating a flowchart is pretty straightforward: You select flowchart nodes from the toolbar on the left side of the canvas and drag them onto the canvas. WEM also allows you to add nodes by selecting various elements from the Project Resources pane on the left of the screen. By connecting the various nodes you create a certain flow: you basically tell the system what should happen in what order. Every node is used for a specific action, like showing a form or retrieving data from an external system. With a node exit, you tell the system what to do next. This way you can use the WEM Modeler to graphically model your application.

In the example above we are adding a new case type, as part of a case management system. The steps:

1. The flow always starts with the Start node;

2. The next step is to add a new row in the Case Type list, using the List action node, where the selected action is "Add row";

3. After creation of the new row, the user is presented with a form to enter the specific Case Type information. This is done using an Interaction node;

4. In the form the user has two options: save all the information or cancel the addition of a new Case Type. Both options are visible in the flowchart.

5. When the user wants to save the new Case Type, the Save database list changes node is executed, and when this node exits, the flowchart also exits by pointing to the End node;

6. When the user decides to cancel the addition of a new Case Type, theDiscard all database list changes node is executed. When this node exits, the flowchart also exits by pointing to the End node;

The example above is a very simple flowchart that shows how the different flowchart nodes can be combined to model a certain function. In this example the addition of a new Case Type.

Node Exits

An important concept in flowcharts are the ‘Exits’. An exit is one of the possible ways a node can exit and is depicted by the arrows on the flowchart that connect the nodes. For example, a ‘Save’ button on a form can be an exit of a User Interaction node; information is stored and the form is closed.

Nodes can have multiple exits, depending on what happens within that node. In the example above there are two exits for the ‘New Case Type’ Interaction Node: Save and Cancel, which both refer to buttons on the form. When no specific exits are defined, the ‘Default exit’ is available.

An exit not only specifies how you can exit a node, but is also used to create your workflow. Every exit can be connected to another node and thus creating a certain workflow. When you model your application, but forget to specify an exit for a certain node, the application will show an error message because it is not clear what should happen. The only exception is the ‘End’ node. When this node is entered, the flowchart has completed and the application returns to the spot where this flowchart started.

Ignore User Input

Flowchart Nodes

On the left-hand side of the flowchart editor canvas, you find all the available nodes that you can use to create the flowchart and functionality you need. Simple drag and drop nodes on the canvas, and draw lines between the nodes to create the flow that is needed. The following nodes are available:

The list node is used to work with lists. When a list node is reached an action can be performed on the list defined by the list node.

When a list node is created, WEM presents a popup where the list for which the action should take place is selected:

The properties and exits of a list node depend on the type of action that should be performed. The property table below presents all options:

The decision node is a very powerfull node that can be used to model bussiness rules in your application. In the decision node a certain condition is specified by using the WEM expression builder. When a flowchart reaches the decision node, the condition is evaluated and based on the outcome (the exit) the flowchart will take a certain route.

Properties

The properties pane of the decision node has only 2 elements: The Expression and a list of the available exits. Therefore it is easy to overlook the versatility of the decision node.

In the expression field it is possible to create incredibly complex statements combining multiple different expressions (like If Then Else, Choose, AND, OR). Allowing the evaluation of complex business rules.

Exits

Decision nodes have several exits, based on what the decision node needs to evaluate. Most people will only use a decision node which evaluates to True or False. However WEM also allowes decision nodes that evaluates to all other Data types. If the Data Type that the decision node returns is Text, Concept or Number, a button appears that allows you to create multiple exits. This opens a lot of possibilities. Some examples are given further down this chapter.

In the table below the most common exits are listed. Not all exits are available for every Data Type.

Default exit

Users have a tendency to only choose the exits that apply in the scenarios they expect. For example in a decision node with a boolean Data type only the Yes and No exits are used. Therefore the default exit is often times overlooked. In reality there are often edge cases that cause an error because the none of the exits used is suitable. Therefore it is advisory to always use the Default exit.

In the example below a decision node is used to evaluate if the user role of the current user is equal to administrator. If Yes then the user should be guided to an administrator screen. If No then the user needs to be guided to the main screen. In this scenario using the Yes and No exit would probably work just fine. But maybe a situation can arise where the expression can't be evaluated. In that case the user would see an error. To prevent that it is better to use the "Default exit" exit instead of the "No" exit.

Save database changes

When the save database changes node is reached, all changes to all database lists that have not yet been saved, are saved.

This node has only 1 property, the Name. The value is set by WEM and cannot be changed by the user. The value is Save all database list changes.

There is also only 1 exit: Changes saved exit.

Discard database changes

When the Discard database changes node is reached, all changes to all database lists that have not yet been saved, are discarded.

This node has only 1 property, the Name. The value is set by WEM and cannot be changed by the user. The value is Discard all database list changes

There is also only 1 exit: Changes discarded.

The Copy Data Node allows you to select a Source List, optionally a list-filter or filter-expression, a Destination list and an easy Mapping overlay to map source values to destination fields.

When a persistent (database) list is used for Destination, the option Save directly to the database is available.

If a nested list is used as Source list, you get the option to limit the copy action to the context of the parent row. If this limit is off, all rows of the nested list will be copied - for all parent-rows.

This node will make it a lot easier and faster to copy data from one list to another.

The loop node makes it possible to loop through all the rows in a list or a multi-select field. When a loop node is dragged onto the canvas, a popup appears where you can select the list or multi-select field over which we need to loop.

When the node is selected the following properties can be specified:

A loop node has two different exits:

• Next row

  When a new row has been reached, the node exits with the Next row exit. In the flowchart the user has to make sure to return to the loop node, in order to loop over the remaining rows.

• End of loop

  When all rows have been looped over, the node exits with the End of loop exit.

If your project has Webservices defined (consume and/or expose), you can access these services through the Service request node. The Service request node sends or retrieves data using a web service. The node itself does not handle any data, so you will need e.g. assignment nodes to store and work with the data. To use the node, you drag it onto the flowchart and a selection popup appears.

Here you select the webservice you want to use.

There are only two properties for this node:

• The Name, which is set by WEM and cannot be changed;

• The possibility to clear all input after the call to the webservice is finished. This is done through checking the checkbox for this option.

The node has a number of exits:

• Error - this exit is used if an error occurs using the node;

• Default exit - the regular exit when there are no errors

• Additional exits are possible if the webservice has predefined faults. If so, these are also exits for this node. And these exits help to better identify a problem if the node produces an error.

Example: when you want to call a webservice to retrieve data, you call that webservice through the node, and the data that is returned is stored in either data fields or list fields. Often a call requires input, in that case you start with one or more assignment nodes to set the input, than the service request node does the call to the webservice, and finally you use one or more assignment nodes to store the data that was retrieved using the service request node.

A complete documention on webservices can be found here:

The data export node is used to export data. When this node is dragged onto the workflow, you will automatically get a popup window where you have to select a list or list filter as the source from which you want to export the data. Next you edit the properties, so you can control the data export. The following properties are available:

This node has two exits:

• Error– this exit is used when the export produces an error;

• Default exit – this exit is used when the data export does not produce any errors.

Edit mapping

When you want to export to Json or XML, you need to specify a mapping to map the exported data to either Json or XML. This works the same as specifying the mappong for data import (see above for a description of how to create a mapping). The only difference is that the mapping will now be used to export data from your WEM application to Jsonor XML instead of importing data into your WEM application.

When this node is reached, an HTTP request will be executed. The HTTP request node supports:

• All common request methods (GET, POST, PUT, DELETE, PATCH, etc.);

• Query parameters (expressions);

• Basic authentication and Client certificate authentication;

• Custom request headers (expressions);

• Custom response headers (mapped to fields);

• If applicable, a request body (text, file or richtext);

• Response body (text, file or richtext).

The type of request, and the HTTP request details are all specified in the node’s properties. Some properties are only needed for certain request types, as is displayed in the example below.

The properties:

The Web request node can have several exits. There are two pre-defined exits:

• Default exit

• Error

  This is the standard error exit for every WEM Node to catch technical code issues within the node itself to prevent showing technical error-details to end users. In this case it should not be used to handle Fault Messages from the Response (which are correct results within the HTTP Request Process - not errors - and have specific HTTP Response Codes which can be handled specifically)

Besides these pre-defined exits, it is possible to define an exit for every possible status code the HTTP Request returns. This includes any "error messages" or "fault messages" that the remote endpoint can provide.

HTTP Status Code Exits

You should check with the provider of the remote endpoint to understand which Response Codes you may expect and could handle specifically.

When you define the Exit by HTTP Code, you currently have to define the specific code (there is no option for "wildcards" like 4xx and 5xx - but this may be provided in future). Then, following the specific HTTP Code Exit, you can handle it accordingly, and the Response Body can contain details of the specific situation so you may want to use that Response Body information as well when displaying feedback to user.

HTTP Status Code Exit or Error Exit?

Basically, you will not use the Error Exit to handle errors that occur on the Remote side - the Error Exit should only be used for situations where the Response is not received (there is no HTTP Status Code) - typically this is for when the Request itself is malformed and causes issues in the WEM Runtime. You should leave the Error Exit unlinked to show the technical information from the WEM Runtime that may indicate a bug or another issue that needs to be fixed. To make things confusing: that error may be displayed as a Server 500 (HTTP Status code 500) error, but this may be the status code from the WEM Runtime, and not from the remote endpoint...

HTTP Status Codes in the 4xx range are considered "client errors" and the 5xx range are considered "server errors" - in any case - if this status code is received in the Response object and there is a corresponding exit, this exit is followed and the Response Body will contain the detailed results from the remote endpoint. As this is mapped to a field in your model, you can just display that information or work some logic on its contents.

HTTP Status Codes 4xx and 5xx as received from the remote endpoint are valid Response Status Codes and are NOT considered Errors that will follow the Error Exit.

The data import node is used to import data into a specified list. The data that is imported is either in CSV, Excel, JSON or XML format. To use this node, simply drag it onto you flowchart and choose the right file format, JSON, XML or CSV/ Excel. Next thing you have to do is change.

This node has two exits:

• Error- this exit is used when the import produces an error;

• Default exit - this exit is used when the data import does not produce any errors.

Edit Mappings

Map CSV or Excel fields

The easiest way to create the mapping, is to hit the Create mapping from example button on the right hand side of the toolbar.

You can now select the CSV or Excel file you want to import, so WEM can learn which columns exist. Once the file is selected, WEM will show a list of all columns from the source file. You can now specify per column to which target field in WEM the data should be mapped / imported. Simply double click on the target field column for the specific CSV/Excel column and WEM will bring up the popup so you can select the actual target field. If needed you can also specify whether this should be a mandatory field and what do do when WEM encounters an invalid value in the source file.

Map Json or XML

To map Json or XML to WEM data, hit the Create mapping from example button on the right hand side of the toolbar to open the mapping tool. When you do this the first time you will get an emtpy screen: no mapping is available. You can create your own mapping by adding your own entities and map these to WEM fields. But it is far easier to use some sample Json or XML and let the WEM modeler do a lot of the work for you. Click on the Create mapping from example button in the toolbar en paste your sample Json on XML into this form. You can verify if you are using correct XML or Json and then click on Ok to let the system create the basic mapping.

When you use Json, you get something that looks like this:

For every array, object, text field, numeric field and boolean you can now specify:

• Is this a mandatory component;

• Do you want to skip an object if the data is invalid.

You can specify this by simply clicking on the component in the tree on the left hand side. You will then see the properties on the right hand side (see ths picture above). Te map a component to a WEM field, simply select the Json field, and in the properties area on the right click on the button of the Map to field. You will get a popup where you can select the WEM field to which you want the map the Json component.

Once you have done this for the entire Json message, you are done with the mapping: click on Save and your mapping is ready to use.

If you want to import XML, you get something that looks like the screen below, after you have created the mapping from an example:

The actual mapping works very similar to the Json mapping described above. The main difference is that the various XML elements can have different properties, based on the value of other properties of the same element. But in essence it works like Json mapping: you can create the entire mapping manually, or you simple import an XML example of the XML you want to import, so you can let the system create the basic mapping. Next, you go over each element and specify:

• The Name (you usually don't change what the system created);

• The Namespace of the XML element. If you use namespaces, you can select them here or create a new namespace;

• Is it a repeating element? If so, you will get another property:

  • You can now specify the Target collection

• Specify whether the element contains:

  • a single value. In this case you can specify where you want to Map the content to. You can select a field that is defined in WEM;

  • nested values (<catalog> or <book> in the example above). When this element contains nested values, you can't specify a mapping, because you should specify the mapping of the elements that are contained in this element.

The process nodes are distributed into 3 categories. Some processes change the settings of your project, confirm changes or affect flowchart flows, there can be found in the change settings category.

Other processes change files or change how documents work or change the document types. These can be found in the changing files categories.

Generate files is reserved for processes that generates new files or components for your project. Here you can find processes that; generate images, sends emails and much more.

The different processes:

Change settings:

• Change language

• Change timezone

• Confirm session changes

• Sleep

• Redirect

• Web request**

Change files:

• Resize Image

• Flatten CSV document

• Extract text from document

• Rename file

Generate file:

• Create data matrix

• Generate Word document

• Generate PDF document

• Generate file from text

• Generate Image

• Generate HTML from rich text

• Create QR code

• Create ZIP archive

Coming soon or Deprecated:

• Send email*

• Print template*

• Write template to rich text field*

Introduction

With the async task nodes you can run tasks in a background process. Async Tasks can be started, stopped and monitored with specific nodes. This can be useful if you want to start long running tasks without having to wait for them to finish. Users can continue their processes and work while the Async Tasks work in the background.

Start Task node

Use this node to start a task created in the project as a background process. Every process has a unique job ID that can be stored in a text dossier item to be used later.

Properties

• (Optional) Store job instance ID: Text dossier item to store the ID.

• (Optional) Task arguments: A list of optional arguments that can be provided as input for the task. The parameters are declared in the input folder under the task.

Exits

• Task queued: The task has been queued to run anytime now.

• Task queue limit reached: The task has not been queued because the limit has been reached.

Stop task node

Use this node to stop a running task with a specific ID.

Properties

• (Required) Job instance ID: Stop running task with this ID.

Exits

• Default exit: Task has been successful stopped.

• Error: An error occurred whilst stopping the task.

Task status node

Use this node to retrieve the status of a running task on demand.

Properties

• (Required) Job instance ID: The running task instance ID to retrieve the status from.

• Store status: Text dossier item to store general status information.

• Store feedback: Text dossier item to store custom feedback from the running task. For more information see the Task feedback node.

• Store error: Text dossier item to store general error information.

Exits

• Task queued: Task has been queued to run later.

• Task running: Task is running.

• Task stopped: Task has been stopped.

• Task stopping: Task is in the process to be stopped.

• Task error: Task has an error.

• Task completed: Task is completed.

• Task not found: Task has not been found.

• Default exit: The exit when other exits are not handled.

Task feedback node

Store any information of this running task instance to be read from other WEM runtime sessions.

Properties

• Feedback expressions: The shared information to stored.

• Append feedback: Should the extra information be appended?

Task input folder

Is a dossier folder of parameters for the current task. The arguments are given by the Start task node. Note that no lists or calculated fields can be created as input parameter.

WEM comes with a large number of pre-defined processes that you can use in your workflow. These processes range from generating documents to sending email or sending data to Google Analytics. When this process node is dragged to the flowchart, a popup window appears where you select the process that you want to use. If you select a particular process you will immediately see which input parameters are availble/necessary for this proces. An example:

Note: By default, no processes are available: you need to define which processes are available through the Project settings for Processes

Once you have selected the process you need in your flowchart, the specific properties become available to configure.

The properties are similar for all processes:

• Name of the node, this is set by WEM and cannot be changed.

• The specific Input parameters for this process.

• The specific Output parameters (for example when a PDF is created, in which File Field to store the result).

• The template that is specific for this process (e.g. the email body in case you want to send an email. You can edit the template by clicking on Edit template. Not all processes have a template, so you will only see this button when a template is available.

An example of the input parameters for the "Send email" process:

On the left is the input parameter name, in the middle column the data type and the right column shows the value, mapped field or expression when entered. On the far right is a button that takes you to the expression editor where you can enter the value for the parameter.

This node has two exits:

• Error- this exit is used when the process results in an error;

• Default exit - this exit is used when the process does not produce any errors.

Change language

Function

With the change language process you can change the language of the user's session in the runtime. You can choose languages from the available languages configured in the project settings. You can find a list of all supported languages and their names in the available languages section.

Properties

For the change language node, we have the following properties:

How to use this node?

There are different ways in which we can implement and use this node, here we will show a basic example that you can later modify according to the need, and the ideas, that you want to implement in your project.

One of the easiest ways to use it:

1. Create a field with the Default Language. In this case we use en-US

2. Inside the properties of the change language process node you insert the datafield you just made.

1. Create an interaction that triggers the change language process, in this case we will use a button that activates the process

Flowchart

For the flowchart, connect from the start node to the interaction node where you want to change the language from. Next is to add the button exit "change" to the process node and connect the default exit back to the interaction screen.

Inside the node properties; put which language the project is going to change into, as the example below shows.

Change Timezone

Function

This process is to change the timezone in the current project. It is important when we handle several timezones within our project. WEM supports the IANA Standard Time zones and uses the tz identifier to name the timezones.

Properties

For the change timezone node, we have the following properties:

Flowchart

For the flowchart, connect from the interaction node to the change language node. In the following example we will be using the start node by default; an interaction node, and the change timezone node as shown below.

For the flowchart, connect from the start to the interaction node, from interaction to the change timezone node and back to the interaction again for the result.

1. Use an interaction node, and put the change timezone node next to the interaction node in the flowchart.

2. Create a field that hold a the timezone you want to change to or put the name in the process node properties.

3. Create an exit that will go to the node to execute the process and use the default exit to go back to your interaction node.

4. Add a button that triggers the exit in your interaction node and a label that shows the current timezone.

Confirm session changes

Function

Its function is to confirm if a session fields is changed and keep its information during this session without specifically making a post or other update (following an exit from a page). The node can be linked to an exit from another node and needs the default exit to have a next step. It will send the changes in session fields at the client/browser to store them on the server in the current session. Very useful in cases where a change in fields on a page can trigger an execute flowchart (containing the confirm session) but return back to the main page - in which case the session on server is not updated (that would only be when user follows an Exit) and the user wants to navigate away using a Navigation Item (without the Confirm Session, the changes will be lost to this session).

Sleep

Function

This function is to set a wait time before the runtime goes to the next node.

Properties

The properties allow us to connect the elements of our project to the process options. For this sleep node, we have the following propertie:

How to use this node?

The following example will show the time in seconds it takes to execute the action of the sleep node.

The objective of this project is basically to visually show the time that the process takes to execute the "sleep" time that is part of the configuration; The process is explained in detail below. For this example project, two values, one initial and one final, are compared, using the assignment of a function type date to give a parameter between both fields. Initial date that starts from one point and ends at another; between this space the time of the sleep node process is calculated.

1. The interaction node.

2. Add an assignment node with the advanced function "now()" that will compare the first number.

3. Add an assignment node with the advanced function "datePart", that will have the start date day, which will compare the first number.

4. An overlay is added to show the executed process in progress.

5. The sleep node has been added with 3 seconds in its property max time.

6. Add an assignment node with the advanced function "now()", that will compare the second number.

7. Add an assignment node with the advanced function "datePart", that will have the end date day, which will compare the second number.

8. The next assignment node will receive the information of the time.

Node operation process.

Describing the process of the flowchart in the preview. Detailed after executing the project.

1. Before clicking the sleep button.
2. The processed overlay, while the node is been executed.
3. The result of the compared fields within the time and sleep process node.

Redirect

Function

This processes is to redirect the user/browser to a specific url - without the need to let user click a link to go there. In this use case, we will be showing a simple way to use it, just as an illustration.

Properties

The properties allow us to connect the elements of our project to the different process parameters of their function. For this redirect node, we have the following:

How to use this node?

For the flowchart, connect from the interaction node to the redirect node as shown below.

One of the easiest ways to use it:

1. Use an interaction node, and put the redirect node on the canvas.

2. Create an exit that will go to the node to execute the process.

1. Set up the redirect node properties to a string with the url you want to point to. The property field is a expression and can be used with a text datafield, with expressions or directly with an url string. This example uses "www.google.com" as string.

Node operation process.

1. Before clicking the "redirect" button, which also is shown as button most of the time.

1. Then, you will go to the URL set, in this case, "google.com"

Webrequest

Webrequest, is the legacy version of the "HTTP" node , which connects with any action of request, get, put, post, delete, etc... This node is updated to a more user-friendly way, for more information about its improvement, you can visit the documentation page with more details.

Resize image

Function

This node is to change the size of an image. When the image is resized, it is scaled to the size best representing the given size property keeping the original scale. This process can be used to decrease image sizes before you add them to files like pdf's or to lessen the file size to restrict impact on performance.

Properties

For this resize node, we have the following properties:

How to use this node?

For the flowchart, connect from the interaction node to the change language node and use the default exit to go to the next or back to the same interaction node.

an example:

1. Create a temporary file field to put the image you want to change and a field for the result.

2. Use an interaction node where you select the image, then we put the Resize Image node.

3. Create an exit that will go to the node to execute the process and use the default exit to go back.

4. Set the node properties,

Node operation process.

1. Before clicking the resize button, the image set is shown with the original size. We can see that the image is quite large at the beginning before executing the resize image node.

2. After clicking the resize button, the image gets the sizes set and the label shows the result. This image has take the size and height fitting closest to the node properties.

Flatten CSV Document

Function

This node is to Transpose CSV data into a new CSV that contains 3 columns: RowNumber, Column and Value for every "fieldvalue" in the original CSV.

Properties

How to use this node?

In the example we have a TEMP 1 field, this holds the resulting csv file, a overlay interaction node where we select the file we want to flatten and give us the resulting file and the process node.

One of the ways to use it:

1. Use an interaction node, then we put the convert Flatten CSV document node.

2. Create a temporary file field that will be the one that receives the converted file.

3. Create an exit that will go to the node to execute the process and connect back to the interaction node to show the result.

Node operation process.

1. Before clicking the flatten CSV button select the file.

2. After executing the process, the temporary field appears with the resulting file.

Extract text from document

The extract text process node is for extracting text from readable text files. The process works for .pdf and .docx files with properly made text. Images of text (in documents) instead of readable text can not be extracted.

properties

How to use this node?

1. Create a transient file field that holds the source file and create a text field for the return text.

2. Open or create the flowchart that performs the process.

3. Add an interaction node for selecting the source file and to show the result.

4. Add the process node and select the extract text process.

5. Connect the start node to the interaction node, then create an exit "extract text" for the interaction node and connect it to the process node.

6. Use the default exit of the process node to return to the interaction screen that now shows the result.

Now open the interaction node to design a quick screen like the image below. On the left a window for selecting the source file and trigger the process, and on the right a label with the respons text.

When you run this in the preview, this is the result:

Rename file

The rename file process is a feature to change the filename of a single file field. The input is an expression for the new name. You can use this for a static name by just putting some text in, or use an expression to generate a filename based on other information. The rename file process can be used to change the filename of multiple files in a list, using a loopnode You should add a check if the filefield to be renamed exists, before entering the process node.

The File Property (a WEM File Field) is used for both Input as well as Output: it is the same field, the same file that will get the new Name as its FileName property after the change.

Properties:

How to use this node

In this example I will be changing the name of all the files to the [ID] name of their respective row.

1. Open or create the flowchart that perform the process

2. Add a interaction node for starting the process to show the return

3. Add the process node and select the change file name process and add a loop node to go trough all the items in a list containing a file field. Fill in the properties of the node. In this case the file field from the datalist "webshop" for the input and output of the file.

4. Connect the start node first to the interaction node, then create an exit "rename file" for the interaction node and connect it to the loop node and that to the process node.

5. Use the default exit of the process node to return to the loop node and the end of loop exit to return to the process node.

The interaction node only activates the process, this does not need any user input besides running it. If you are not sure every row has a file, you should add a decision node between the loop and the process that goes back to the loop if there is no value (use HasValue or IsEmpty functions).

Create Data Matrix

Function

Its function is to generate a Data Matrix (kind of QR code), this can be used to convert text information to a graphical representation matrix of black and white pixels. These are often used for inventory tracking or to hold information about products.

Properties

The properties:

How to use this node?

For the flowchart, connect from the interaction node to the create data matrix and back to the interaction with the result using the default exit.

One way to use it:

Sample use case

1. Create a temporary file field that will store the generated image.

2. Use an interaction node with a button to start the process, an input field and a label for the result.

3. Put the Data Matrix node in and set the properties.

4. Create an exit that will go to the node to execute the process.

Node operation process.

1. After executing the process, the temporary field appears, in this case, a file field data type.

1. The result of the process, with the data matrix generated.

Generate word

Function

Its function is to generate a Word Document from the contents of a provided WEM Template.

Properties

This process has the following properties:

How to use this node?

Flowchart

For the flowchart, connect from the interaction node to generate Word node. As shown below we have the interaction node where we want to activate the process and see the response, and the process node is connected with the button exit and back with the default exit.

One way to use it:

1. Create a temporary text field that will be the one that receives the document file.

2. Use an interaction node, then, the Generate Word Document node.

3. Create an exit that will go to the node to execute the process and use the default exit for the response.

In the node properties, the "edit template" gives access to a template in which you can create what you want to add in the future Word document, this template is similar to the editor that appears inside the interaction node;

Node operation process.

1. Before clicking the generate word button.

1. as After executing the process, the temporary field appears the one that will carry the result of the executing of the node.

1. The result.

Generate PDF

Function

Its function is to generate a PDF Document through the node configuration. WEM allows, through the templates editor, templates to be converted into a PDF document.

Properties

The properties that can be used in the PDF process:

How to use this node?

Flowchart

Connect from the interaction node to generate PDF. In the canvas, the process flow that will be executing the project is designed, in the following example, we will be using the start node that will always be by default; an interaction node as shown below, fill in the properties section, where can be set the different dimensions of the future PDF document.

One of the easiest ways to use it basically:

Sample casse an interaction node, then, the Generate PDF document node.

1. Create a temporary file field that will be the one that receives the PDF file field.

2. Create an exit that will go to the node to execute the process.

In the node properties, the "edit template" gives access to a template in which you can create what you want to add to future PDF files, this template is similar to the editor that appears inside the interaction node;

Node operation process.

1. Before clicking the generate pdf button.

2. The result of the process executed.

File from text

Function

Its function is to generate a file from text through the interaction node configuration, it is quite interesting and it will help us when we have to make a file that comes from a text type; in a direct and immediate way. You can take text-type fields that contain information loaded in advance, either manually, or with one of the options offered by the import node, through CSV, Excel, JSON, XML, or through an external list of Odata, web service, an API, etc…

Properties

How to use this node?

Flowchart

Connect from the interaction node to generate a File from text. In the canvas, the process flow that will be executing the project is designed, in the following example, we will be using the start node that will always be by default; an interaction node as an "overlay", as shown below.

One of the easiest ways to use it basically:

1. Use an interaction node, then, the Generate file from text.

2. Create a temporary file field that will be the one that receives the file from text.

3. Create an exit that will go to the node to execute the process.

Node Operation Process.

1. Before clicking the button "Generate file from text".

1. After clicking file from text, the field appears.

1. The result.

Generate image

Function

Its function is to generate an image through the interaction node configuration. Generating an image through this process execution node, allows everything that has been developed within an interaction node with its template edition, to be captured in an image which can be customized according to the idea of the user. The most fascinating thing about all this is that it is extremely easy to use and can contribute to many useful processes in systems development.

Properties:

How to use this node?

One of the easiest ways to use it basically:

1. Use an interaction node, then we put the generate image node.

2. Create a temporary text field that will be the one that receives the image file.

3. Create an exit that will go to the node to execute the process.

In the node properties, the "edit template" gives access to a template in which you can create what you want to add in the future Image file, this template is similar to the editor that appears inside the interaction node;

Node operation process.

1. Before clicking the generate pdf button.

2. After executing the process, the temporary field appears.

Generate HTML from rich text

Functions

Its function is to change generate a generate HTML from a rich text field.

Properties

How to use this node?

One of the ways to use this node

The first thing we do is use an interaction node, then we put the generated HTML from the rich text node.

Inside the file content, set the HTML.

After, create a temporary text field which will be the one that receives the generated HTML file.

Create an exit that will go to the node to execute the process.

Node operation process.

1. Before clicking the generate HTML from rich text button.

1. After executing the process, the temporary field appears.

1. The result.

Create QR-code

Function

With this process node you can generate different kinds of qr-codes, this is an image that can be read by a lot of devices. The process translates a text to a grid of black and white pixels, this can be translated back to text by all kinds of devices with a camera. A lot of times qr-codes are used to share information without having to retype it. This is someting different then a datamatrix which is used in a lot of warehouses management.

Properties

Among the properties, it presents:

How to use this node?

One of the easiest ways to use it is shown below, we start with a interaction node, here we provide the input for the qr code and set up a few of the options. The interaction node has a exit to the qr process node, and uses the default exit to go back and show the result.

Sample use case

1. The first thing we do is use an interaction node, and a field to store the code that is made. In this case is that a transient or session field where we temporary store the image.

2. You can leave all the settings on default by keeping them empty or add values to them. In the images below you will see that there are a few transient fields added for specific settings.

3. Add a button that triggers the node exit Create QR-code thats connected to the process node. and add the field that you used for the output to the interaction template.

Node operation process.

1. Fill in the input field with the code you want to convert.

2. select the create code button that invokes the process

3. The result of the process, with the QR-code generated.

Create ZIP archive

Function

Its function to create a ZIP archive.

Properties

Among the properties, it presents:

How to use this node?

One of the easiest ways to use it basically

Sample use case

1. The first thing we do is use an interaction node, then we put the generate Generate Zip Archive.

2. Create a temporary text field that will be the one that receives the Generate Zip Archive.

3. Create an exit that will go to the node to execute the process and back again to show the result.

You have created a ZIP packager, this can be used when working with large files you want to save in the datamodel.

The ping server node is just what is sounds like. You can use the ping server node to ping a specific server and look for the right response. This can be used to check if a specific server is reachable and responding for example.

A note is not a node like the ones described before. a note is exactly that: a notation that you can drop on you flowchart. You could use this to explain the flow, place it behind a part of the flowchart to highlight that part, etc.

You can have multiple notes on you flowchart.

Using this node is the way to realize single sign-on in WEM. Let's say the authentication provider is Microsoft Active Directory. When the user is already logged into the company network, the authentication node will recognize this and won't ask for a username/password. If the user has not been logged in, he/she will be asked to log in. When this is done, the user is logged onto the company network, so all other applications that use Active Directory will recognize this as well.

The authentication node can be used to authenticate a user, using a pre-defined authentication provider (). Using this node is simple: drag it to the workflow where the authentication needs to take place (e.g. the Home flowchart) and make sure the workflow passes this node. Once the node has been reached, the pre-defined authentication provider does the user authentication. There are a few properties:

The node has three possible exits:

• Authenticated - in this case the user is authenticated

• Not authenticated - the authentication failed or the user is logged out

• Error - the authentication resulted in an error

In WEM it is possible to generate messages, and listen to message. Based on these messages a specific action can be taken (e.g. write to a log or display popup on all user's screens). This happens in realtime. And to use this functionlity, you need the realtime message node:

• You need a node to send a message;

• You need one or more nodes to listen to messages ("Chanels");

• You can use a node to stop listening.

The properties of the node define how the node will behave: as a sender or a listener. Let's look at the various properties. For the various node "Actions", there is a different set of properties. Three properties are always available:

• Name: the name of the node, which is set by WEM and cannot be changed;

• Channel name: this is the name of the messaging channel you want to use. You are free to give it any name you want, as long as it is unique within the application. When you are listening to messages, or want to stop listening to messages, you need to specify the name of an existing channel;

• Action: This property defines how the node will behave:

  • Start listening - the node will behave as a listener on a particular channel;

  • Send message - the node will now behave as a sender on a particular channel;

  • Stop listening - the node will stop the the listening on a particular channel.

Depending on the action, the remaining properties vary.

Start listening

Send message

Stop listening

This node has two exits:

• Error- this exit is used when the node produces an error;

• Default exit - this exit is used when there are no errors.

Introduction

With the OpenAI Node, you can tap into the advanced natural language processing capabilities of the OpenAI API, which utilizes cutting-edge machine learning techniques to generate responses to a variety of different inputs. The OpenAI Node has a few different versions for different uses, such as transcribing or translating audio, creating images, completing and editing text, and chat completion.

The Node has two exits: the default exit is used when the API returns a good response, and the Error exit is used when the OpenAI API does not return a proper response. This can happen for a lot of reasons, for example, if the API is used too much, if the prompt or response is too long, or if it is not accepted.

How to use AI

The usefulness and experienced quality of AI and its different models are dependent on how you use it and what you expect. The model generates text responses based on patterns and information it has learned from a dataset of responses created by humans. This means it will respond to the text but not to its meaning. This is especially evident when asking mathematical questions; it will confidently respond with numbers not knowing if it is the actual result of the math problem.

Here are a few tips to get the best results

• Provide plenty of context or details to help it better understand what you want as response.

• Be specific in your request and provide as much detail as possible. This will yield more precise answers.

• Cross-check information from other reliable sources, especially for critical or factual information.

• Provide context to your question; this will help recieve more tailored responses.

• Do not combine questions; instead, break them up into multiple requests. This will result in more focused responses.

If you want to learn more about how to get most out of the OpenAI models, visit the . They offer excellent tips and guides to help you use it as a powerfull tool rather than a gimmick.

Models

Text completion

The most recent version of the GPT model is called "GPT-3", and it is currently available in several different sizes or "variants" ranging from 125 million to 175 billion parameters. The names of the specific API endpoints that correspond to the different GPT-3 variants are as follows:

• "ada" (with 0.6 billion parameters) (default)

• "babbage" (with 1.5 billion parameters)

• "curie" (with 6.7 billion parameters)

• "davinci" (the largest and most powerful variant, with 175 billion parameters)

So, if you were to use the GPT-3 API, you would specify the variant you want to use by specifying the corresponding API endpoint, such as "davinci" for the largest variant.

Text edits

The text version is trained specifically on large amounts of natural language text, and is particularly adept at generating high-quality, human-like responses to prompts. It can be used for a wide range of natural language processing tasks, such as language translation, summarization, and sentiment analysis.

The code version of the Davinci model is specifically designed to work with programming languages and code. It can be used to generate code snippets based on natural language prompts, and can also be used for code completion and other related tasks. This model is particularly useful for developers and anyone working with code who needs help generating complex code structures quickly.

Image

The image generator uses the DALL-E model, this is a version of GPT-3 trained to generate images from text descriptions, using a dataset of text-image pairs.

Properties

Chat Completion

This node allows you to create a conversational chatbot that can respond to user input. It uses OpenAI's language model to generate responses based on user input, making it ideal for customer service or other types of conversational applications.

Edit Text

The Text version allows you to input a text prompt, and OpenAI will generate an edited version of that text based on the input parameters you provide. This can be useful for tasks such as copy, editing or generating variations of marketing messages.

The Code version, on the other hand, allows you to input a code snippet, and OpenAI will generate an edited version of that code. This can be useful for tasks such as optimizing code or generating new ideas for algorithms.

Complete Text

This Node allows you to generate a complete text based on a given prompt. This is useful for generating text for various applications like customer service responses and content creation. This Node uses a model that is less powerful for chatbots than the Chat Completion Node.

Create image

This node enables you to generate images using OpenAI's generative model. You can input a text prompt and the node will generate an image based on that text. This is useful for generating graphics, logos, and other types of images.

Translate audio

This node enables you to translate audio from one language to another. It uses OpenAI's GPT-3 natural language processing capabilities to recognize and translate the spoken language.

Transcribe Audio