Portals Extension Module

Overview

This article provides comprehensive documentation on the Portals Extension Module, which allows integration of third-party content and applications within Portals. It covers various aspects of the API, including initialization, message bus usage, data querying, and interaction with MySight Tableau instances.

Information

The Portals Extension Module documentation is divided into several sections, each focusing on different aspects of the API and its functionality. This guide will help developers integrate their applications with Portals and utilize various features provided by the API.

• Including Portals API in your application
• Using the Portals message bus
• Querying data from Portals
• Trigger actions in Portals
• Accessing MySight instances in Portals
• Listening to MySight Tableau events
• Use Portals styles
• Opening a dialog in Portals

Including Portals API in your application

The Extension module allows integration of your application into portals by providing an iFrame for your content and an API for communication with Portals. The module accepts an url and allows dynamic GET parameters to be passed to your application through that url. Just select the participant variables and master data you want to pass to your application and provide names for the GET keys.
A portals page can have several Extension modules on a single page and all modules can communicate with each other through the provided message bus in the Portals API.
For enhanced data exchange with EFS, we recommend that your application uses the EFS ServiceLayer in the backend to query and update data in EFS.

Import

In your application, you have to import the PortalsAPI JavaScript file in order to be able to use the message bus or other Portals API functions.

<script src="https://{yourEFSInstallation}/public/modules/portals/dist/portalsApi/portalsApi-1.0.js"></script>

Initialization

After your document has finished loading you need to initialize the api. This registers your document with Portals for messaging.

<script>
    Questback.portalsApi.initialize()
        .then(function() {
            ...
        }
        .catch(function(error) {
            ...
        });
</script>

Checking initialization status

You can check the initialization status by calling isInitialized, though it is generally recommended to do your api operations in the then-handler of the initialize method as shown above.

Questback.portalsApi.isInitialized();

Unregister

You can completely revert the registration of the iFrame and unregister all its handlers by calling unregister.

Questback.portalsApi.unregister();

---

Using the Portals message bus

The message bus is intended for communication between extension module iFrames. You can send and listen to your own events and transfer any data you want.

Listening for messages

After the initialization has been completed you can start to register handlers for events from other iFrames. The example code registers a handler for an event called "myEvent". This is an event name that you expect other iFrames to send messages for.

Questback.portalsApi.initialize().then(function() {
    Questback.portalsApi.bus.subscribe('myEvent', function(data) {
        ...
    });
};

Sending messages

Sending a message to other iFrames is just as simple. You just call the send method with an eventname that you chose and a data object as second parameter.

Questback.portalsApi.bus.send('myEvent', { foo : "bar"});

Just note that you do not get a result back from this call, as it works like a broadcast. Also note that by default the sending iFrame will not receive its own event back, even if it has registered a handler for it. You can supply a third parameter to send with a value of true to force sending the event to the sender iFrame, too.

Stop listening for messages

You can remove handlers for events by an eventname.

Questback.portalsApi.bus.unsubscribe('myEvent');

Note that this removes all handlers for the given eventname for this iFrame at once.

---

Querying data from Portals

The api supplies a set of methods to request specific data from Portals.

query.portalInfo

Get information about the portal.

Questback.portalsApi.query.portalInfo().then(function(result) {
    console.log(result.portal.id);
});

query.user

Get the user object of the currently logged in user. Returns null if there is no logged in user.

Questback.portalsApi.query.user().then(function(result) {
    console.log(result.user);
});

query.language

Get the language object of the currently used language.

Questback.portalsApi.query.language().then(function(result) {
    console.log(result.language);
});

query.token

Returns the Portals Api token, which can be used in external software to additionally validate the user via EFS web service.

Questback.portalsApi.query.token().then(function(result) {
    console.log(result.token);
});

If the user is logged in, the token field will contain the users api token, which you can validate by calling the following EFS web service. Otherwise, token will be an empty string.

portal.users.getUserDataByToken

If the token is valid the userId and portalId is returned. Otherwise an exception is thrown. Please refer to the web services documentation for more details on this service call.

query.deviceInfo

Get information about the client device.

Questback.portalsApi.query.deviceInfo().then(function(result) {
    console.log(result.device.isMobile);
});

query.ajax (reserved for future use)

Makes an ajax call to the internal portals server API and returns the result. Since Portals itself does not provide a public portals server API, this function is reserved for future use.

Questback.portalsApi.query
    .ajax('GET', '/api/portal/client/pages')
    .then(function(result) {
        console.log(result);
    })
    .catch(function(error) {
        console.log(error);
    });

---

Trigger actions in Portals

The api supplies a set of methods to trigger specific actions in Portals.

trigger.height

Set the iFrames height to a specified value, given as a string including the unit.

Questback.portalsApi.trigger.height('300px');

trigger.autoHeight

Set the iFrames height to the height of its content. This is done once per call, not repeatedly. So you have to react to resize events yourself.

Questback.portalsApi.trigger.autoHeight();

trigger.logout

Log out the current user from Portals and thus redirect to the configured landing page. The iFrame will be removed from the DOM by this opreation.

Questback.portalsApi.trigger.logout();

trigger.route

Redirect to the given page slug. The iFrame will be removed from the DOM by this opreation.

Questback.portalsApi.trigger.route('targetPageSlug');

---

Accessing MySight instances in Portals

There are a number of methods to interact with Tableau in a MySight module. For all of these you need the pageModuleIdentifier of a MySight module to target your requests. This identifier is set in the Portals CMS in the settings for the MySight page module and can be reused on other pages for the same or even different Tableau instances.

mySight.vizGetIsReady

Gets whether the onFirstInteractive event has been fired yet.

Questback.portalsApi.mySight.vizGetIsReady(pageModuleIdentifier)
    .then(function(ready) {
        ...
    });

mySight.vizGetAreTabsHidden

Gets whether the tabs are hidden or not.

Questback.portalsApi.mySight.vizGetAreTabsHidden(pageModuleIdentifier)
    .then(function(hidden) {
        ...
    });

mySight.vizGetIsToolbarHidden

Gets whether the tabs are hidden or not.

Questback.portalsApi.mySight.vizGetIsToolbarHidden(pageModuleIdentifier)
    .then(function(hidden) {
        ...
    });

mySight.vizGetUrl

Gets the url of the viz.

Questback.portalsApi.mySight.vizGetUrl(pageModuleIdentifier)
    .then(function(url) {
        ...
    });

mySight.vizGetCurrentUrl

Gets the current url of the viz.

Questback.portalsApi.mySight.vizGetCurrentUrl(pageModuleIdentifier)
    .then(function(currentUrl) {
        ...
    });

mySight.vizGetIsHidden

Gets whether the viz is hidden or not.

Questback.portalsApi.mySight.vizGetIsHidden(pageModuleIdentifier)
    .then(function(hidden) {
        ...
    });

mySight.vizShow

Shows the viz.

Questback.portalsApi.mySight.vizShow(pageModuleIdentifier)
    .then(function() {
        ...
    });

mySight.vizHide

Hides the viz.

Questback.portalsApi.mySight.vizHide(pageModuleIdentifier)
    .then(function() {
        ...
    });

mySight.vizDispose

Disposes the viz.

Questback.portalsApi.mySight.vizDispose(pageModuleIdentifier)
    .then(function() {
        ...
    });

mySight.vizGetAreAutomaticUpdatesPaused

Gets the status of automatic updates.

Questback.portalsApi.mySight.vizGetAreAutomaticUpdatesPaused(pageModuleIdentifier)
    .then(function(paused) {
        ...
    });

mySight.vizPauseAutomaticUpdates

Pauses automatic updates.

Questback.portalsApi.mySight.vizPauseAutomaticUpdates(pageModuleIdentifier)
    .then(function() {
        ...
    });

mySight.vizResumeAutomaticUpdates

Resumes automatic updates.

Questback.portalsApi.mySight.vizResumeAutomaticUpdates(pageModuleIdentifier)
    .then(function() {
        ...
    });

mySight.vizToggleAutomaticUpdates

Toggles automatic updates.

Questback.portalsApi.mySight.vizToggleAutomaticUpdates(pageModuleIdentifier)
    .then(function() {
        ...
    });

mySight.vizRevertAll

Restores the initial state. Note that url parameters will be ignored in this operation and as such the restored state may differ from the real initial state.

Questback.portalsApi.mySight.vizRevertAll(pageModuleIdentifier)
    .then(function() {
        ...
    });

mySight.vizRefreshData

Refreshes data from the server.

Questback.portalsApi.mySight.vizRefreshData(pageModuleIdentifier)
    .then(function() {
        ...
    });

mySight.vizShowDownloadWorkbookDialog

Shows the download workbook dialog.

Questback.portalsApi.mySight.vizShowDownloadWorkbookDialog(pageModuleIdentifier)
    .then(function() {
        ...
    });

mySight.vizShowExportImageDialog

Shows the export image dialog.

Questback.portalsApi.mySight.vizShowExportImageDialog(pageModuleIdentifier)
    .then(function() {
        ...
    });

mySight.vizShowExportPDFDialog

Shows the export PDF dialog.

Questback.portalsApi.mySight.vizShowExportPDFDialog(pageModuleIdentifier)
    .then(function() {
        ...
    });

mySight.vizShowExportDataDialog

Shows the export data dialog for the current or a specific sheet.

Questback.portalsApi.mySight.vizShowExportDataDialog(pageModuleIdentifier, sheetName)
    .then(function() {
        ...
    });

mySight.vizShowExportCrossTabDialog

Shows the export cross tab dialog for the current or a specific sheet.

Questback.portalsApi.mySight.vizShowExportCrossTabDialog(pageModuleIdentifier, sheetName)
    .then(function() {
        ...
    });

mySight.vizShowShareDialog

Shows the share dialog for the current or a specific sheet.

Questback.portalsApi.mySight.vizShowShareDialog(pageModuleIdentifier, sheetName)
    .then(function() {
        ...
    });

mySight.vizSetFrameSize

Sets the vizs frame size. Note that the min-width might be set to 100% by Portals, taking precedence over any width that is set here.

Questback.portalsApi.mySight.vizSetFrameSize(pageModuleIdentifier, width, height)
    .then(function() {
        ...
    });

mySight.workbookGetName

Gets the name of the workbook.

Questback.portalsApi.mySight.workbookGetName(pageModuleIdentifier)
    .then(function(name) {
        ...
    });

mySight.workbookGetSheetsInfo

Gets information about all sheets.

Questback.portalsApi.mySight.workbookGetSheetsInfo(pageModuleIdentifier)
    .then(function(sheetsInfo) {
        ...
    });

mySight.workbookGetActiveSheetName

Gets the name of the active sheet.

Questback.portalsApi.mySight.workbookGetActiveSheetName(pageModuleIdentifier)
    .then(function(name) {
        ...
    });

mySight.workbookGetActiveSheetIndex

Gets the index of the active sheet.

Questback.portalsApi.mySight.workbookGetActiveSheetIndex(pageModuleIdentifier)
    .then(function(index) {
        ...
    });

mySight.workbookActivateSheet

Actives a sheet by its name or index.

Questback.portalsApi.mySight.workbookActivateSheet(pageModuleIdentifier, sheetNameOrIndex)
    .then(function() {
        ...
    });

mySight.workbookRevertAll

Restores the initial state of the workbook. Note that url parameters will be ignored in this operation and as such the restored state may differ from the real initial state.

Questback.portalsApi.mySight.workbookRevertAll(pageModuleIdentifier)
    .then(function() {
        ...
    });

mySight.workbookGetParameterNames

Gets a list of the parameter names.

Questback.portalsApi.mySight.workbookGetParameterNames(pageModuleIdentifier)
    .then(function(names) {
        ...
    });

mySight.workbookGetParameterCurrentValue

Gets the current value of a parameter.

Questback.portalsApi.mySight.workbookGetParameterCurrentValue(pageModuleIdentifier, parameterName)
    .then(function() {
        ...
    });

mySight.workbookGetParameterDataType

Gets the data type of a parameter.

Questback.portalsApi.mySight.workbookGetParameterDataType(pageModuleIdentifier, parameterName)
    .then(function(dataType) {
        ...
    });

mySight.workbookGetParameterAllowableValuesType

Gets the type of allowable values of a parameter.

Questback.portalsApi.mySight.workbookGetParameterAllowableValuesType(pageModuleIdentifier, parameterName)
    .then(function(allowableValuesType) {
        ...
    });

mySight.workbookGetParameterAllowableValues

Gets a list of allowable values of a parameter.

Questback.portalsApi.mySight.workbookGetParameterAllowableValues(pageModuleIdentifier, parameterName)
    .then(function(allowableValues) {
        ...
    });

mySight.workbookGetParameterMinValue

Gets the min value of a parameter.

Questback.portalsApi.mySight.workbookGetParameterMinValue(pageModuleIdentifier, parameterName)
    .then(function(minValue) {
        ...
    });

mySight.workbookGetParameterMaxValue

Gets the max value of a parameter.

Questback.portalsApi.mySight.workbookGetParameterMaxValue(pageModuleIdentifier, parameterName)
    .then(function(maxValue) {
        ...
    });

mySight.workbookGetParameterStepSize

Gets the step size of a parameter.

Questback.portalsApi.mySight.workbookGetParameterStepSize(pageModuleIdentifier, parameterName)
    .then(function(stepSize) {
        ...
    });

mySight.workbookGetParameterDateStepPeriod

Gets the date step period of a parameter.

Questback.portalsApi.mySight.workbookGetParameterDateStepPeriod(pageModuleIdentifier, parameterName)
    .then(function(dateStepPeriod) {
        ...
    });

mySight.workbookChangeParameterValue

Sets a parameter to a given value.

Questback.portalsApi.mySight.workbookChangeParameterValue(pageModuleIdentifier, parameterName, value)
    .then(function(newValue) {
        ...
    });

mySight.sheetGetName

Gets the name of a sheet by its index.

Questback.portalsApi.mySight.sheetGetName(pageModuleIdentifier)
    .then(function(name) {
        ...
    });

mySight.sheetGetIndex

Gets the index of a sheet by its name.

Questback.portalsApi.mySight.sheetGetIndex(pageModuleIdentifier)
    .then(function(index) {
        ...
    });

mySight.sheetGetIsActive

Gets whether a sheet is active or not.

Questback.portalsApi.mySight.sheetGetIsActive(pageModuleIdentifier, sheetNameOrIndex)
    .then(function(active) {
        ...
    });

mySight.sheetGetIsHidden

Gets whether a sheet is hidden or not.

Questback.portalsApi.mySight.sheetGetIsHidden(pageModuleIdentifier, sheetNameOrIndex)
    .then(function(hidden) {
        ...
    });

mySight.sheetGetType

Gets the type of the currently active or a specific sheet.

Questback.portalsApi.mySight.sheetGetType(pageModuleIdentifier, sheetNameOrIndex)
    .then(function(type) {
        ...
    });

mySight.sheetGetUrl

Gets the url of the currently active or a specific sheet.

Questback.portalsApi.mySight.sheetGetUrl(pageModuleIdentifier, sheetNameOrIndex)
    .then(function(url) {
        ...
    });

mySight.sheetGetSize

Gets the size of the currently active or a specific sheet.

Questback.portalsApi.mySight.sheetGetSize(pageModuleIdentifier, sheetNameOrIndex)
    .then(function(size) {
        ...
    });

mySight.sheetChangeSize

Sets the size of the active sheet.

Questback.portalsApi.mySight.sheetChangeSize(pageModuleIdentifier, sheetSizeOptions)
    .then(function() {
        ...
    });

mySight.sheetGetFilters

Gets the filters of a sheet specified by its name.

Questback.portalsApi.mySight.sheetGetFilters(pageModuleIdentifier, sheetName)
    .then(function(filters) {
        ...
    });

mySight.sheetApplyFilter

Applies the filter for a sheet specified by its name.

Questback.portalsApi.mySight.sheetApplyFilter(pageModuleIdentifier, sheetName, fieldName, values, updateType, options)
    .then(function(fieldName) {
        ...
    });

mySight.sheetApplyRangeFilter

Applies the range filter for a sheet specified by its name.

Questback.portalsApi.mySight.sheetApplyRangeFilter(pageModuleIdentifier, sheetName, fieldName, range)
    .then(function(fieldName) {
        ...
    });

mySight.sheetApplyRelativeDateFilter

Applies the relative date filter for a sheet specified by its name.

Questback.portalsApi.mySight.sheetApplyRelativeDateFilter(pageModuleIdentifier, sheetName, fieldName, options)
    .then(function(fieldName) {
        ...
    });

mySight.sheetApplyHierarchicalFilter

Applies the hierarchical filter for a sheet specified by its name.

Questback.portalsApi.mySight.sheetApplyHierarchicalFilter(pageModuleIdentifier, sheetName, fieldName, values, options)
    .then(function(fieldName) {
        ...
    });

mySight.sheetClearFilter

Clears the filter for a sheet specified by its name.

Questback.portalsApi.mySight.sheetClearFilter(pageModuleIdentifier, sheetName, fieldName)
    .then(function(fieldName) {
        ...
    });

---

Listening to MySight Tableau events

The api supports registering for a number of Tableau events. The supported events are:

• FIRST_INTERACTIVE

• VIZ_RESIZE

• TAB_SWITCH

• FILTER_CHANGE

• PARAMETER_VALUE_CHANGE

• MARKS_SELECTION

To register a listener for an event use the apis bus methods together with the apis tableau event constants:

Questback.portalsApi.bus.subscribe(
  Questback.portalsApi.mySight.tableauEventFirstInteractive, function(event) {
    console.log(event);
});

Questback.portalsApi.bus.subscribe(
  Questback.portalsApi.mySight.tableauEventVizResize, function(event) {
    console.log(event);
});

Questback.portalsApi.bus.subscribe(
  Questback.portalsApi.mySight.tableauEventFilterChange, function(event) {
    console.log(event);
});

Questback.portalsApi.bus.subscribe(
  Questback.portalsApi.mySight.tableauEventTabSwitch, function(event) {
    console.log(event);
});

Questback.portalsApi.bus.subscribe(
  Questback.portalsApi.mySight.tableauEventParameterValueChange, function(event) {
    console.log(event);
});

Questback.portalsApi.bus.subscribe(
  Questback.portalsApi.mySight.tableauEventMarksSelection, function(event) {
    console.log(event);
});

Note that you will receive events coming from any MySight Tableau instance on the page, so upon receiving an event you might have to make sure that you are only handling events coming from a specific instance by checking the pageModuleIdentifier in the event object.

Questback.portalsApi.bus.subscribe(
  Questback.portalsApi.mySight.tableauEventVizResize, function(event) {
    if (event.mysight.pageModuleIdentifier === 'page-module-identifier-to-handle') {
        // Do something
    }
});

Use Portals styles

You can use Portals CSS styles by importing its stylesheets into your iframe. The following examples will guide you through the setup process.

Retrieve file paths

First you need to get the paths of the stylesheet files and font definitions:

Questback.portalsApi.initialize().then(function() {
    Questback.portalsApi.query.portalInfo().then(function(result) {
        // Continue here with step 7.2
    });
});

The result parameter will contain the necessary information in its layout field:

{
    portal: {...},
    layout: {
        customCss: "<https://PORTALS-DOMAIN/portals/PORTALS-ID/css/compile.css?v=123456",>
        portalsCss: "<https://PORTALS-DOMAIN/portals/PORTALS-ID/css/custom.css?v=123456",>
        extensionCss: "<https://PORTALS-DOMAIN/portals/PORTALS-ID/css/extension.css?v=123456",>
        fontCss: "<https://fonts.googleapis.com/css?family=Lato",>
        fontDefinition: "'Lato', sans-serif",
    }
}

These paths do not change for a given portal (besides the value of the cachebuster parameter called v), so it is possible to retrieve them once, store them and hardcode them into your code, to save postMessage requests and improve startup times a little.

Importing the extension stylesheet

After retrieving the stylesheet urls you need to import the files by adding link tags into your documents head:

var head = document.getElementsByTagName('head')[0];
var linkExtension = document.createElement('link');
linkExtension.setAttribute('rel', 'stylesheet');
linkExtension.setAttribute('type', 'text/css');
linkExtension.setAttribute('href', result.layout.extensionCss);
head.appendChild(linkExtension);

You should note that it takes some time to retrieve the file from the server, so there is a short time in which your application is rendered without the styles in the file. You might want to prevent your application from beeing shown to the user before the above code has been executed.

The extension.css is a subset of the portals stylesheet and contains the necessary styles for the most common use cases. If you want to include the complete portals stylesheet you can import result.layout.portalsCss instead of result.layout.extensionCss. But be aware that this might introduce conflicts with existing styles in your application.

Importing the custom stylesheet

If you have added custom css in the Look & Feel section of the CMS, that contains styles which you want to apply to you application, then you should import the custom.css file, too.

var linkCustom = document.createElement('link');
linkCustom.setAttribute('rel', 'stylesheet');
linkCustom.setAttribute('type', 'text/css');
linkCustom.setAttribute('href', result.layout.customCss);
head.appendChild(linkCustom);

Importing the portals default font

To use the same font as your portal use the following code:

if (result.layout.fontCss) {
    var linkFont = document.createElement('link');
    linkFont.setAttribute('rel', 'stylesheet');
    linkFont.setAttribute('type', 'text/css');
    linkFont.setAttribute('href', result.layout.fontCss);
    head.appendChild(linkFont);

    // Apply font-family definition
    var body = document.getElementsByTagName('body')[0];
    body.style.fontFamily = result.layout.fontDefinition;
}

Using the styles

The extension.css contains classes for the most common use cases.

Color variables

/* Color variables definitions */
:root {
    --ext-primary-color: #006BFE;
    --ext-secondary-color: #606c76;
    --ext-success-color: #2ccc76;
    --ext-warning-color: #fbbf5f;
    --ext-danger-color: #fd6e72;
    --ext-info-color: #006bff;
    --ext-text-color: #444444;
    --ext-sidebar-background-color: #0a061d;
    --ext-sidebar-text-color: #ffffff;
}

Type color classes

Classes exist for the most common type and property combinations:

.ext-text-primary
.ext-text-secondary
.ext-text-success
.ext-text-warning
.ext-text-danger
.ext-text-info

.ext-background-primary
.ext-background-secondary
.ext-background-success
.ext-background-warning
.ext-background-danger
.ext-background-info

.ext-border-primary
.ext-border-secondary
.ext-border-success
.ext-border-warning
.ext-border-danger
.ext-border-info

Profile background classes

The profile background classes exist, too:

.ext-profile-background-0
.ext-profile-background-1
.ext-profile-background-2
.ext-profile-background-3
.ext-profile-background-4
.ext-profile-background-5
.ext-profile-background-6
.ext-profile-background-7
.ext-profile-background-8
.ext-profile-background-9

Other classes

.ext-text-color
.ext-sidebar-background
.ext-sidebar-text

Buttons

You can style your buttons by using the portals button classes:

<button class="btn btn--md btn--primary btn--gloss">Click</button>

The button size can be set by adding one of the following classes:

btn--xs
btn--sm
btn--md
btn--lg

The type can be set by adding one the following classes:

btn--default
btn--primary
btn--secondary
btn--cancel
btn--clear
btn--success
btn--warning
btn--danger
btn--info
btn--contrast
btn--transparent

To enable hover effects, add the following class:

btn--gloss

To display a button as disabled, add the following class:

btn--disabled

If the button has the "disabled" attribute, the styles of "btn--disabled" are applied automatically.

Input fields

You can use styles for input fields as well. Write your markup as follows:

<div class="input input--animated">
    <input type="text" oninput="this.value ? this.classList.add('input-filled') : this.classList.remove('input-filled');">
    <label>
        <span class="text-ellipsis">This is the label</span>
    </label>
</div>

Please pay attention to the order of the elements and their classes. The oninput event handler is required to add or remove the input-filled class according to the inputs value. If your input receives an initial value you have to add the input-filled class manually.

Selectboxes

You can use native html selectboxes and they will be styled as close as possible to the original portals selectboxes. As those are generated by JavaScript, an exact replication is not possible.

<div class="input input--animated input--select">
    <select class="input-filled">
        <option value="1">Value 1</option>
        <option value="2">Value 2</option>
        <option value="3">Value 3</option>
    </select>
    <label>
        <span>This is the label</span>
    </label>
</div>

As native html selectboxes always have a value selected, the input-filled class is always set on the select element.

Opening a dialog in Portals

The portalsApi has four methods that give you the ability to open a dialog outside of the scope of your iframe.

Questback.portalsApi.trigger.openDialog(text, title)
Questback.portalsApi.trigger.openConfirmDialog(text, title)
Questback.portalsApi.trigger.openIframeDialog(url, title, height, heightUnit)
Questback.portalsApi.trigger.openIframeConfirmDialog(url, title, height, heightUnit)

Dialog buttons

The methods openDialog and openIframeDialog open a dialog with a single "Close" button. The corresponding methods openConfirmDialog and openIframeConfirmDialog open a dialog with a "Cancel" and an "Ok" button.

Text dialogs

The methods openDialog and openConfirmDialog take a string as first parameter, which is the text shown in the main area of the dialog. The title is optional.

Iframe dialogs

The methods openIframeDialog and openIframeConfirmDialog render an iframe in the main area of the dialog with the url given at the first parameter. The title, height and heightUnit are optional. The paramters height and heightUnit define the height of the iframe in the dialog.

Simple call

The simplest way to open a dialog is by calling one of the dialog methods, give a text/url and not worry about any events:

Questback.portalsApi.trigger.openDialog('This is a simple dialog!');

Handle dialog close

The dialog can either be closed or canceled/accepted and this event can be handled by implementing Promise methods, like this:

Questback.portalsApi.trigger.openDialog('This is a simple dialog!')
    .then(function() {
        console.log("Dialog has been closed");
    });

The confirm dialogs make use of the then and catch methods:

Questback.portalsApi.trigger.openConfirmDialog('This is a confirmation dialog!')
    .then(function() {
        console.log("Dialog closed by ok button");
    })
    .catch(function() {
        console.log("Dialog closed by cancel button");
    });

The catch method does not indicate that an error happened, it just tells you about the way the dialog was closed. Both methods do not get any parameters. This means that no data from the dialogs iframe is transported back to the calling iframe.

If you want to transport data between the iframes or trigger actions in the other iframe make use of the PortalsApi's message bus functionality, documented under Using the Portals message bus.

FAQ

What is the Portals Extension Module?

The Portals Extension Module is a feature that allows integration of third-party content and applications within Portals. It provides an iFrame for your content and an API for communication with Portals.

How do I initialize the Portals API?

You can initialize the Portals API by calling Questback.portalsApi.initialize() after your document has finished loading. This method returns a Promise that resolves when the initialization is complete.

Can I communicate between different iFrames in Portals?

Yes, you can use the Portals message bus to send and receive messages between different iFrames. Use Questback.portalsApi.bus.send() to send messages and Questback.portalsApi.bus.subscribe() to listen for messages.

How can I apply Portals styles to my application?

You can import Portals CSS stylesheets into your iframe. Retrieve the stylesheet paths using Questback.portalsApi.query.portalInfo() and then add them to your document's head using JavaScript.

Can I open dialogs from my application in Portals?

Yes, the Portals API provides methods to open dialogs outside the scope of your iframe. You can use methods like Questback.portalsApi.trigger.openDialog() or Questback.portalsApi.trigger.openIframeDialog() to open dialogs in Portals.