Configuration

Runtime config

Use Lime Admin to configure Lime BI. The Lime BI section only appears when config.addons.lime_bi is true in the application config. See Lime application config.

Setup

Go to Lime BI, Setup in Lime Admin, pick a Sync language, and click Initialize and Sync. That connects the Lime CRM database to Metabase and synchronizes the data structure in one step. On an application that is already connected the same button reads Sync and only synchronizes.

After that, sync again only when you have changed the data structure in LISA, or when you want the synchronized fields in another language.

Widgets

Only for the web client

A widget points at one saved question or dashboard, and is what you place in the client. Add one under Widgets and fill in:

Setting	What it does
Unique Name	The name you refer to the widget by when placing it.
Type	Question or Dashboard.
Lime BI item	The question or dashboard to embed.
Render on limetype	The object cards the widget can be placed on. Leave empty for a start page widget.
Display label	Optional title shown on the widget, one entry per language.
Lime BI parameters	Feeds a filter on the dashboard with a value from Lime CRM. See below.
Remove download button	Hides the download buttons on the embedded widget.
Token expiration (minutes)	How long the embed URL stays valid, between 1 and 30. Defaults to 2.
Restrict To	Only members of the selected Lime CRM groups see the widget. Intended for object cards; do not rely on it for start page widgets.

Lime BI parameters

A parameter feeds a filter on the dashboard with a value from Lime CRM, so one dashboard can show different data depending on where it is placed. Only dashboards take parameters.

Add the filter to the dashboard first:

1. Open the dashboard and click the pencil icon to enter editing mode.
2. Click the filter icon and pick the filter type.
3. Select which field the filter maps to for each question on the dashboard.
4. Optionally set a Default value in the sidebar.

Then add a parameter to the widget in Lime Admin:

Setting	What it does
Parameter name	The filter to feed, picked from the ones on the dashboard.
Type of parameter	Active coworker reads from the logged in user's coworker, Active object from the object the card is open on.
Field name	The field the value is read from. For Active object, only fields common to every limetype in Render on limetype are offered.

Example with the active company

A dashboard showing deal values, narrowed to the company you have open.

Add a filter named company_id to the dashboard and connect it to the company field of each question. Then configure a Dashboard widget with Render on limetype company and a parameter reading Lime Object Id from the Active object. In the Code view:

{
  "widgets": [
    {
      "parameters": [
        {
          "name": "company_id",
          "type": "activeObject",
          "field": "_id"
        }
      ],
      "name": "deal values",
      "type": "dashboard",
      "id": 3,
      "token_expiration": 5,
      "limetypes": ["company"],
      "label": [
        {
          "lang": "en",
          "text": "Total deal value"
        }
      ]
    }
  ]
}

Example with the active coworker

A dashboard showing only the deals where the logged in user is the responsible coworker.

Add a filter named coworker_id to the dashboard and connect it to the coworker field of each question. Then configure a Dashboard widget with no Render on limetype, and a parameter reading Lime Object Id from the Active coworker. In the Code view:

{
  "widgets": [
    {
      "parameters": [
        {
          "name": "coworker_id",
          "type": "activeUser",
          "field": "_id"
        }
      ],
      "name": "My deal values",
      "type": "dashboard",
      "id": 3,
      "token_expiration": 5,
      "limetypes": [],
      "label": [
        {
          "lang": "en",
          "text": "My deals total value"
        }
      ]
    }
  ]
}

Config keys

Lime Admin renders these settings as a form. The Code switch shows the same settings as JSON, using these keys:

Setting	Key
Unique Name	name
Type	type
Lime BI item	id
Render on limetype	limetypes
Display label	label
Lime BI parameters	parameters
Parameter name	parameters[].name
Type of parameter	parameters[].type
Field name	parameters[].field
Remove download button	download_button
Token expiration (minutes)	token_expiration
Restrict To	restrict_to

Dashboard Publication

Under Lime BI, Dashboard Publication in Lime Admin, click Add Dashboard. The Dashboard dropdown shows every dashboard that is not published yet. Publish makes it publicly available, with no authentication necessary.

Click the external link icon to open the published dashboard in a new tab. Its URL contains a unique ID that only exists on published dashboards. To reverse the process, click Unpublish. That deletes the unique ID and makes the URL useless. The next time you publish the same dashboard, a new ID is generated.

Info

On-premise, public sharing must be enabled in Metabase under Admin settings, Public sharing. The installer enables it by default.

Metabase users and groups

On-premise only. In cloud, each application's group and its permissions are set up for you.

Lime BI is reached from the user menu in the web client. Lime CRM administrators and members of the Lime CRM group Lime BI get that entry; nobody else can sign in.

What someone can see once they are in is decided by the Metabase groups they belong to. Lime CRM users are created in Metabase the first time they sign in through Lime BI, and start out in All Users only.

Groups are managed in Metabase. Click the ⚙️ in the top right, click Admin settings, then go to People, Groups. From there you can create a group and add people to it. Someone has to have signed in through Lime BI at least once before they can be added.

Access is granted per group under Admin settings, Permissions, in two places:

• Databases — whether the group may query the Lime CRM database.
• Collections — which collections the group may see.

Both are needed. A group with collection access but no database access can open a dashboard and see no data in it.

Web client

Lime BI provides two components, Lime BI Widget (limebi-graphics) and Lime BI Tile (limebi-tile). The widget renders the question or dashboard directly on the page, which suits questions that do not need much space. The tile renders a small shortcut and opens the question or dashboard in a dialog, which suits dashboards and more detailed questions.

Both ask you to pick a widget from a dropdown. Without one selected the component renders nothing.

On a start page

Follow the start page instructions to add a component to a start page. We recommend at least the rectangle size for a Lime BI Widget and a small rectangle for a Lime BI Tile.

On an object card

Add Lime BI Widget or Lime BI Tile to the card view config of the desired limetype, as shown below, then pick the widget.

The dropdown only offers widgets whose Render on limetype includes that limetype. Widgets with it left empty are start page widgets and will not appear.

Desktop client

How to configure dashboards

In order to embed dashboards in the desktop client, the activeUser needs to be listed under dataSources for the ActionPad in _config.js. See example further down on this page.

An example config of four dashboards is shown below.

<div data-app="{
    app: 'limebi',
    config: {
        dashboards:
            [
                {
                    dashboardId: '1',
                    userIds: [29901, 1001],
                    title: 'openlimebi',
                    whereToOpen: 'overview'
                },
                {
                    dashboardId: '2',
                    userGroups: ['Administrators', 'Users'],
                    title: 'openlimebi',
                    whereToOpen: 'overview'
                },
                {
                    dashboardId: '3',
                    coworker: {field: 'department', value: 1501},
                    title: 'openlimebi',
                    whereToOpen: 'overview'
                },
                {
                    dashboardId: '4',
                    coworker: {field: 'department', value: 1101},
                    title: 'openlimebi',
                    whereToOpen: 'overview'
                }
            ]
    }}"></div>

The title of each dashboard should match a localization code with the owner addon_limebi.

Users and groups

There are different ways to configure who should see the dashboards as shown in the example above. Think of this not as a security functionality, but as a convenience functionality.

• userIds lets you specify the id of the users that should see the dashboard.
• userGroups lets you specify for which group the dashboard should be visible.
• coworker lets you filter on a field on the coworker card, e.g. department.

Make sure that activeUser is listed under dataSources in the config you find in _config.js (see example further down in this documentation).

Overview and panes

Lime BI can be embedded and shown in either the overview window or as panes. The overview window is limited to only show one dashboard at a time, but with panes you can show multiple dashboards in separate tabs. Simply specify with the key whereToOpen if you want the dashboard to open in the overview, or in its own pane-tab.

<div data-app="{
    app: 'limebi',
    config:{
        dashboards: [
            {
                dashboardId: '1',
                userGroups: ['Users'],
                title: 'openlimebi',
                whereToOpen: 'overview'
            },
            {
                dashboardId: '2',
                userGroups: ['Users'],
                title: 'openlimebi',
                whereToOpen: 'panes'
            },
            {
                dashboardId: '3',
                userGroups: ['Users'],
                title: 'marketingdash',
                whereToOpen: 'panes'
            },
        ],
    }
}"></div>

Lime BI on a card

To embed lime BI on a card, for example a company card, add a html-view (tab) on the desired card.

In the config, whereToOpen should be set to explorer and explorer should specify the name of the html-view. Make sure that activeInspector is listed in dataSources for the card through the _config.js config (see further down in this documentation).

<div data-app="{
    app: 'limebi',
    config:{
        dashboards: [
            {
                dashboardId: '2',
                userGroups: ['Users'],
                title: 'openlimebi',
                whereToOpen: 'explorer',
                explorer: 'limebi',
            },
            {
                dashboardId: '3',
                userGroups: ['Users'],
                title: 'marketingdash',
                whereToOpen: 'explorer',
                explorer: 'limebi',
            }
        ]
    }
}"></div>

Embedding parameters

in the app-config, you can add params with a name (the name of the filter/parameter in lime-bi), a type (there is support for activeInspector and activeUser), and a field (The field on the record or coworkercard depending on type)

<div data-app="{
    app: 'limebi',
    config:{
        dashboards: [
            {
                dashboardId: '3',
                userGroups: ['Administrators'],
                title: 'marketingdash',
                whereToOpen: 'explorer',
                explorer: 'limebi',
                params: [
                    {
                        name: 'myDepartmentParam',
                        type: 'activeUser',
                        field: 'office'
                    },
                    {
                        name: 'mySecondParam',
                        type: 'activeUser',
                        field: 'id'
                    },
                    {
                        name: 'myRecordParam',
                        type: 'activeInspector',
                        field: 'id'
                    },
                    {
                        name: 'myFinalParam',
                        type: 'activeInspector',
                        field: '<field on active inspector>'
                    },
                ]
            }
        ]
    }
}"></div>

Make sure that the card you embed it on has the activeUser and activeInspector listed as dataSources in _config.js.

config: {
  index: {
    dataSources: [
      { type: 'localization', source: '' },
      { type: 'activeUser', source:''}
    ],
    autorefresh : false
    },
  company: {
    dataSources: [
      {type: 'activeUser', source:'',},
      {type: 'activeInspector', source: ''},
      {type: 'localization', source: '' },
      {type: 'relatedRecord', source: 'person', view: 'name;phone;email;mobilephone', alias: 'person'},
    ],
    autorefresh : false
  }
}