Development of a UI Designer page as done at Bonitasoft, Part Two
Published: 2021-05-10 10:37:12

This article is a continuation of the article [Development of a UI Designer page as done at Bonitasoft, Part 1](https://dev.to/dumitrucorini/development-of-a-ui-designer-page-as-done-at-bonitasoft-bp5) in which I talked about general page design choices, and then specifically about a list-styled page. I suggest reading that first before you read this.

In this article, I will detail the *edit group* modal. I chose to focus on this as it has most of the things you can find in other modals - and more.

## Modal general decisions

To talk about modals, we first need to talk about the widget itself. The modal widget cannot be included inside another container in the whiteboard, which means that a UI Designer developer needs to choose where to put the container. When we started using the modal widget, our team decided to put modal widgets at the bottom of the editor, just as the UI Designer recommends.

### Embed modal containers

Our team made a choice early in the development process to not allow a modal to be opened by another modal, so we had to look for other options when we had to decide how to edit something inside a modal. We wanted to simplify the user flow, because opening a modal inside another one raises questions about what would happen in the case of partial changes.

### Keep the page consistent with changes made inside a modal

To keep the page consistent with the changes that are made inside a modal, we usually append a timestamp to the url that needs to be called. This way, if we update information in the groups list, all we have to do is modify the timestamp to trigger the API call again and get the recent changes.

### Opening and closing a modal

Next up is our way of handling the closing and reopening of a modal. In the current UID state, there is no way of closing the modal easily since a modal can be closed in two different ways: with a button, and by clicking outside of it. Thus, there is no way to clean the modal state when closing the modal window. This causes problems when, for example, you have a modal state that is specific to an item; you close it and then open a modal for a second item. The state of the second modal will carry over some information from the first modal. Our solution was to clean the state of the modal upon opening. 

### Modal mock-up

Since the *edit group* modal is similar to the ones that we have already designed in other pages, we decided to not create a mock-up for this one in particular. Nonetheless, here’s a mockup of what we usually do for a modal:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/p5y4xuri1d39t3bhi4u6.png)

### Modal structure

To style the modal and separate its parts, we use three different containers in the modal and add the css classes “modal-header”, “modal-body” and “modal-footer” to the top, middle and bottom containers. That lets us separate the modal into three sections as you can see on the image above. I should mention that these are bootstrap classes and thus we don’t need to create css specially for them. In rare cases, if needed, we can tweak the style to, for example, add a bigger edge on the sides of the modal. In the case of the *edit group* modal, we didn’t change anything in the default bootstrap styles.

### The *edit group* modal 

This modal will be used by the end-user to modify a specific group. The fields that we let the end-user modify are the name, display name, description of the group, as well as the parent group.

## Implement the *edit group* modal

As explained in [Development of a UI Designer page as done at Bonitasoft, Part 1](https://dev.to/dumitrucorini/development-of-a-ui-designer-page-as-done-at-bonitasoft-bp5), whenever we work on a feature we try to use up to four variables. In this case, we will only create two : `editGroupData` and `editGroupCtrl`. 

For the API call variable, we tried using one to get the information of the current parent, but as it was a bit too complex to manage, it became its own modular feature. I will talk about this feature later in the article.

The fourth variable type is a handler. I’m going to talk about it later as well since we decided to merge it with handlers of other page features. 

And lastly, we have the two buttons at the bottom of the modal. I will talk about these at the end of the article. 

#### How to open the modal

To avoid problems with states that persist after reopening a modal, initialize the modal with the item to edit when the modal is opened. This is then passed to the modal when it opens. To do this, add a function in the controller `editGroupCtrl`. 

The function will look like this:

```
return {
    initEditGroupModal: function($item) {
        $data.editGroupData.selectedGroup = $item;
        return "editGroupModal";
    }
};
```

Also add the selected group to the data variable `editGroupData`, which will look like this:

```
return {
    selectedGroup: {}
};
```

Next, use the `initEditGroupModal` function in the edit button, in the repeatable container list created in part one. Set the action of the button to *Open modal*, use an expression for the *Modal id* property, and then use `editGroupCtrl.initEditGroupModal($item)` as the value. Now, whenever we click the edit button in the list, it will call the `initEditGroupModal` function and pass the row item from the list as a parameter.

Use this selected group to show the display name of a group inside the `modal-header` container:

```
{{"Edit group"|uiTranslate}} {{editGroupData.selectedGroup.displayName}}
```

This should be good for the modal title.

### Edit the group’s simple fields

Since we want to make the modal the same as the one in the current portal, we will provide the end user with the ability to modify fields like name, display name, description and parent group. The first two will be simple input fields, and we decided to use a text area for the description since it would display better. I will go into detail about the parent group a bit later since modifying it is a bit more complex.

Let’s backtrack a bit and talk about the editGroupData variable again and its use in the above mentioned fields. The variable will be used to keep the values of the input fields during the runtime. Thus, its updated value will be:

```
return {
    name: "",
    displayName: "",
    description: "",
    selectedGroup: {}
};
```

Use the editGroupData.name for the name input, and name the other inputs accordingly. 

The `initEditGroupModal` function also needs to be updated to show the values of the display name, name and description when the user opens the modal. To do this, add these lines:

```
$data.editGroupData.name = $item.name;
$data.editGroupData.displayName = $item.displayName;
$data.editGroupData.description = $item.description;
```

Another way to do this would be to use the fields of the object `selectedGroup` instead of three individual fields (name, displayName, description).

Let’s talk about the parent group now. Since the API request for the group returns an id for the parent group and we want the display name, we will need to do an API call `currentParentUrl` to get the information. Since the parent of our group is another group, the API call will look something like this: `../API/identity/group/{{editGroupData.selectedGroup.parent_group_id}}`

Add an input field and use the `currentParentUrl.displayName` to display the current parent group.

You should have something like this: 

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/bspi1sztabpzyo3cb1aq.JPG)

### Edit the parent group 

What we have done so far is display the current parent group, and now we want to be able to edit it. Since we already made a decision to not open a modal by another modal, our team next decided to go with an input that has two states (view and edit). We also wanted to let the user be able to go back to the current parent group if they changed their mind midway through the choice of a new parent group.

To make this modular, we created three variables (currentParentUrl, currentParentData and currentParentHandler). For the currentParentData, we used:

```
return { 
    currentParentId: undefined,
    timestamp: 0
}
```

We also changed the currentParentUrl to `../API/identity/group/{{currentParentData.currentParentId}}?t={{currentParentData.timestamp}}` and added `$data.currentParentData.currentParentId = $item.parent_group_id;` to the `initEditGroupModal` 
to reset the current parent when opening a new modal and `$data.currentParentData.timestamp = new Date().getTime();` to get the information for the new parent. 

If the `currentParentId` is the same when we enter the modal,  there is no need for an API call to get the parent information.

#### Switch between the *view* and *edit* states

Next add the second (edit) state, and a button next to each one of the inputs to switch between the two states. You should have something like this:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/qtu0xj4nxt7bwrjb3edt.JPG)

For these buttons to change the state, we will use a collection of actions. Whenever the end user clicks on one of the buttons, we will add a value into this collection. The handler will then catch and treat the action that was added. 

First add the array to the `currentParentData`. We also need a variable that will keep the current state (editingParentGroup). After these additions, the data variable should look something like this:

```
return {
    currentParentId: undefined,
    actions: [],
    editingParentGroup: false
};
```

Now, set the button actions to *Add to collection*. The position in the array where you add the value doesn’t really matter, but the *value to add* should be `edit` for the first one and `cancel` for the second one. 

Let’s talk about the last piece of the puzzle, the handler.

Its value will be this:

```
if ($data.currentParentData.actions[0] === "edit") {
    $data.currentParentData.editingParentGroup = true;
    $data.currentParentData.actions = [];
}

if ($data.currentParentData.actions[0] === "cancel") {
    $data.currentParentData.editingParentGroup = false;
    $data.currentParentData.actions = [];
}
```

This changes the state, and empties the actions array to execute the action only once. 

For these values to be taken into account, use this field in the two input field containers. Use `currentParentData.editingParentGroup` as an expression for the hidden property value of the first button, and `!currentParentData.editingParentGroup` for the second.

Don’t forget to change the `initEditGroupModal` function to reset the values of the above fields when the user opens the modal. Simply add these lines to the function:

```
$data.currentParentData.currentParentId=$item.parent_group_id;
$data.currentParentData.editingParentGroup = false;
```

#### Implement the edit state

Now that you can change between the view and edit state, make the edit state work. As there is an autocomplete in the portal, we wanted to have something similar here. The catch is that the autocomplete widget that is provided in the UID doesn’t support returning an entire object - it only returns one field from the object. 

Returning an entire object is important since we want to have both the id of the selected item and the display name to display. (Note that there is a fix in the 2021.1 version of the UI Designer that will let you return an entire object. We will update the pages accordingly.)

Since this fix is not yet here, the current implementation of a custom autocomplete uses a repeatable container. To do this, put the two parent group inputs into a single container and add another container for the autocomplete suggestions of possible parent groups. Display a text widget title with the value `<strong>{{"Name" | uiTranslate}}</strong>` to tell the end user to choose between the names of the parent groups. The container added under the *Name* title will be a repeatable container and, thus, it will have one option per row, just like we did with the list in part one. We will set the value of the collection property for this container later.

You should have something like this:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/girrscobfu1399p082yq.JPG)

##### Get the list of possible parent groups

Now, for the functional part. We created a full-fledged feature module here since it will also be used by the create group modal. 

The first variable is `parentDropdownData`. Its value is:

```
return {
    searchParentValue: "",
    selectedParentDisplayName: undefined,
    selectedParentId: undefined,
    selectedParent: []
};
```

`searchParentValue` is used as the value of the input. The `selectedParent` acts as a sort of action array when a parent is selected, from which `selectedParentDisplayName` and `selectedParentId` are extracted. 

We extract these because we found it easier to work with `$data.parentDropdownData.selectedParentDisplayName` instead of `$data.parentDropdownData.selectedParent.displayName`, but you can use the the second option if you want. 

Since we have the data, we can use `parentDropdownData.searchParentValue` as the value of the edit state input.

The second variable is the `parentDropdownUrl`. Its value is `../API/identity/group?p=0&c=20&o=name&s={{parentDropdownData.searchParentValue}}`. 

When the value is defined in the variable itself, an API call will be made when the page is opened and there will be no value for `parentDropdownData.searchParentValue`. So to fix this, create the third variable, `parentDropdownCtrl` and add a function:

```
getParentSearchUrl: function() {
    if ($data.parentDropdownData.searchParentValue && 
        $data.parentDropdownData.selectedParentDisplayName !== 
        $data.parentDropdownData.searchParentValue) {
            return "../API/identity/group?p=0&c=20&o=name&s="+$data.parentDropdownData.searchParentValue;
    }
    return undefined;
}
```

If an API call variable has *undefined* in it’s value then the API call is not made. So, first check if there is a value in the input; if there is no value, there is no need to do an API call. Next check if the value entered is the same as the one that is selected, so the API call is not made again. 

(Imagine you want to look for *Acme* and you type *A*. An API call will be made to search for *A*. When you select *Acme* from the returned values, there is no need to redo an API call with *Acme.*)

Use `{{parentDropdownCtrl.getParentSearchUrl()}}` as the value for `parentDropdownUrl`.
Now that there is an API call, there is another thing to consider before displaying the result. Displaying the full list of possible parents could introduce possible performance issues, so we went with displaying only 20 and then telling the user to type more. To do this, append the *Or type more* to the list of 20 elements. We can add this to `parentDropdownCtrl`:

```
getFullSearchParentList: function() {
    var fullParentList = $data.parentDropdownUrl;
    if (fullParentList && fullParentList.length == 20) {
        fullParentList.push({
            displayName: uiTranslate("Or type more...")
        });
    }
    return fullParentList;
}
```

To display the list of parents, use `parentDropdownCtrl.getFullSearchParentList()` as the collection property value of the repeatable container.

##### Select a parent group from the list

Now add a button in the repeatable container that, when clicked, triggers the selection of a parent group. To make it prettier, we went with a style property *link*. Like the other action trigger, the button has *Add to collection* as the action property. The collection would be `parentDropdownData.selectedParent` and the value is an expression with the value `$item`. This lets you add the selected parent group object into the array. For the label, use `{{$item.name}}` to display the name of each item in the repeatable container. 

Then, create the fourth and last variable `parentDropdownHandler`. Like the one for switching between the view/edit states, this one will catch a variable state, perform an action and clean the variable so the action is done only once. To do this:

```
if ($data.parentDropdownData.selectedParent && 
    $data.parentDropdownData.selectedParent.length > 0) {
        $data.parentDropdownData.searchParentValue=$data.parentDropdownData.selectedParent[0].displayName;
        $data.parentDropdownData.selectedParentDisplayName=$data.parentDropdownData.searchParentValue;
        $data.parentDropdownData.selectedParentId=$data.parentDropdownData.selectedParent[0].id;
        $data.parentDropdownData.selectedParent = [];
}
```

This sets the input field to the value selected, extracts the two fields that we want and cleans the selected parent, so the action is not re-triggered.

Now for the finishing touches for the autocomplete. Since the user should not be able to click on *Or type more*, add a function that will make the option unclickable. To add into the `parentDropdownCtrl`:

```
isSearchParentMore: function(item) {
    return item.name === uiTranslate("Or type more...");
}
```

Use this function by using a disabled expression with the value `parentDropdownCtrl.isSearchParentMore($item)`. This will check if the item has the value of the field `name` equal to *Or type more* and disable it. 

If you run this, you should see a small problem: the dropdown is always visible. To fix this, use an expression for the hidden property of the repeatable container with the value `parentDropdownCtrl.hideDropdownMenu()`. This function checks if there has been no API call response for the `parentDropdownUrl`. If the response is empty (no parents are available with the current search value) or if the current search value is empty (nothing in the input):

```
hideDropdownMenu: function() {
    return !$data.parentDropdownUrl
           || $data.parentDropdownUrl.length === 0
           || $data.parentDropdownData.searchParentValue === "";
}
```

Then clean the `parentDropdownUrl` when a value is selected so the suggestion box disappears. Add `$data.parentDropdownUrl = undefined;` to the `parentDropdownHandler`.

And you should be good for the autocomplete. The end result will look like this:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/hnhffg02ocbzmbmbglkk.JPG)

##### Style of the autocomplete

Before continuing, let’s look at the styling of what was just done. Let’s start by adding the css classes. If you look at the image above, the bottom container uses the class `dropdown dropdown-parent-group`, while the container that displays the names of the possible parents uses `dropdown-menu`. We use the `dropdown` and `dropdown-menu` classes from bootstrap and add `dropdown-parent-group` to be able to override the default definition with a more specific CSS class. 

Also add this to the style.css file:

```
.dropdown-parent-group .dropdown-menu {
    /* so that it stays on screen and avoids a scrollbar in the modal */
    position: relative;     
    display: block;
    /* to make it’s width the same as the input width*/
    width: 95%;
    /* to align it with the parent group input */
    margin-left: 15px;
    padding-left: 10px;
}

.dropdown-parent-group .dropdown-menu button {
    /* ellipsis */
    white-space: nowrap;
    overflow: hidden;
    text-overflow: ellipsis;
    text-align: left;
    /* for it to not surpass the size of the entire container */
    width: 98%;
}

.dropdown-parent-group .dropdown-menu button:hover {
    /* so that it shows which item is selected */
    background: #2c3e50;
    color: #fff;
    /* so that some things are removed */
    text-decoration: none;
}
```

### The action buttons

There are two action buttons in the modal footer. Let’s look at the first one, the *Save* button. This button will be used to make a PUT API call with the URL `../API/identity/group/{{currentParentData.currentParentId}}`. Next, create the payload that will be sent when the end user clicks on the button. Create a function in `editGroupCtrl` called `getEditGroupPayload`:

```
getEditGroupPayload: function() {
        return {
            name: $data.editGroupData.name,
            displayName: $data.editGroupData.displayName,
            description: $data.editGroupData.description,
            parent_group_id:$data.parentDropdownData.selectedParentId
        };
}
```

This function will create a json object with the values that have been input by the end user. You  can now use this function (`editGroupCtrl.getEditGroupPayload()`) in the *Data sent on click* property of the button. Don’t forget to set it as an expression, since the value needs to be calculated instead of being interpreted as text. Two things should be done when we get a response. The first is to show an appropriate message depending on the response of the API call. The second is to refresh the list in the background.

Tackle these one at a time. For the first one, add  `statusCode: “”` to the `editGroupData` and use it in the *HTTP status code* property field (`editGroupData.statusCode`). You can then add text fields that will be hidden if the value of the statusCode is different than the one for the message. 

For example, here are three uses of this variable:
* Use in case of a success. The hidden value should be `editGroupData.statusCode !== 200`. The message will be hidden if the API call response status code is not 200. 
* Use in case of an error. The hidden value is `editGroupData.statusCode === "" || editGroupData.statusCode === 200`. It will be hidden if there is no statusCode (when no API call was made) or when the API call is a success.
* Use in case of a specific error code, but where multiple errors are possible. For example, the group API returns a 403 if the user is not authorized to access the API and if a group already exists with the same name. To treat this, use a variable `failedResponse` in the failed response value and a function `getErrorMessageFor403` that will take the failed response and return an error message. It will look like this:

```
getErrorMessageFor403: function(failedResponse) {
    if (failedResponse
        && (failedResponse.exception.indexOf(‘AlreadyExistsException’) > -1
        || failedResponse.message.indexOf('AlreadyExistsException') > -1)) {
            return uiTranslate("A group with the same name already exists.");
    }
    return uiTranslate("Access denied. For more information, check the log file.");
}
```

All this does is check if the error is of type *AlreadyExistsException*, by checking if that text exists in the exception or the message of the failed response. The text can be customized as you please. To use it in a text widget, use
`{{editGroupCtrl.getErrorMessageFor403(editGroupData.failedResponse)}}` as the value.

#### Refresh the list of items after an API call

Let’s backtrack a bit and talk about refreshing the list of groups that should happen behind the modal. Just as the `parentDropdownHandler` treats the response of the API call for the possible parents, create a `refreshHandler` that will allow editing a group. First, add a timestamp field in the `groupsData` and add `&t={{groupsData.timestamp}}` at the end of the `groupsUrl`. As explained at the beginning of this article, updating this timestamp will trigger the API call again. The rest should be simple - when there is a successful API call for the save button, change the `groupsData.timestamp`:

```
if ($data.editGroupData.statusCode === 200) {
    $data.groupsData.timestamp = new Date().getTime();
}
```

This implementation has a huge flaw though: it will cause an infinite loop of refreshing the page when the group has been successfully edited. This is because the value of the field `statusCode` in `editGroupData` stays at 200, and the timestamp keeps changing every time there’s an action on the page (like, for example, an API call response that arrives). The easiest way that we found to fix this is to have an additional variable that will see if a group has been updated recently. Add `hasRecentlyBeenEdited` to the `editGroupData`. Change the `refreshHandler` code to take this field into account:

```
if ($data.editGroupData.statusCode === 200 && !$data.editGroupData.hasRecentlyBeenEdited) {
    $data.groupsData.timestamp = new Date().getTime();
    $data.editGroupData.hasRecentlyBeenEdited = true;
}
```

And, again, don’t forget to reset it’s value in the `initEditGroupModal` function:

```
$data.editGroupData.hasRecentlyBeenEdited = false;
```

You can disable the button when the name value is empty. Add  `editGroupData.name === ""` as an expression for the disabled property of the *Save* button. You can also disable all the fields after an update by checking that the `hasRecentlyBeenEdited` value is true.

The last thing to consider for this modal is the cancellation button in the modal footer. If there is a successful update of the group, the label *Cancel* might make the end user think the update could be cancelled, so change the label to *Close*. This is done, once again, with the use of a function:

```
getChangeButtonLabel: function(statusCode) {
    return statusCode === 200 ? uiTranslate("Close") : uiTranslate("Cancel");
}
```

We added this to the `groupsCtrl` since it’s also used in other modals.

This is how the full modal looks in the end on our side.

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/arimqozu53d6tm6dpmp1.JPG)

And this in the preview:

![Alt Text](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/2mv6h4f9toc15n8t4dje.JPG)

# Conclusion

So, now you know how we develop a modal with the UI Designer and you can do the same, with all the tips and tricks that we employed, like how to use a UID button to trigger an action on the page, how to create an autocomplete widget custom implementation, and how we treat errors using an API call response.

And, as mentioned in Part 1, the next step is to create tests. You can find more information about how to test a Bonita UI Designer page in [this article](https://dev.to/dumitrucorini/how-to-test-a-bonita-ui-designer-page-using-cypress-466e). You can also find everything about this development and more in our [web pages project](https://github.com/bonitasoft/bonita-web-pages/tree/dev/uid-pages).