Default Entitlement

Summary

By default every Module has an AccessLevel of Full (unless overridden)
This default AccessLevel can be changed by developers using either a hard-coded value or a function

Developers can set the Default Access Level for Module Entitlements in AdapTable.

This is the Entitlement AccessLevel that will be used if not overridden through explicitly-set Module Entitlements.

The Default Entitlement can be one of 3 values:

ReadOnly
Hidden
Full

The property is set using the defaultAccessLevel property in Entitlement Options and it offers 2 ways to provide Entitlements:

Hard Coded Value - an explicitly provided Default AccessLevel
Function - a Default AccessLevel returned from a custom function

defaultAccessLevel

Default: Full

AccessLevel

Set the default AccessLevel to use for Entitlements

AccessLevel

The AccessLevel which will be used for all Entitlements for this user if they are not overridden by moduleEntitlements

The property returns an AccessLevel and is defined as follows:

defaultAccessLevel?: 
  | AccessLevel | ((defaultAccessLevelContext: DefaultAccessLevelContext) => AccessLevel);

The DefaultAccessLevelContext property is defined as follows:

Property	Description
adaptableApi	Adaptable Api object
adaptableContext	Custom application Context provided in `AdaptableOptions.adaptableContext`
adaptableId	Id of current AdapTable instance
adaptableStateKey	Current Adaptable State Key
clientTimestamp	Time on user's computer
userName	Name of Current User

Caution

If this property is not provided, the default Entitlement set by AdapTable for every Module is Full.

Hard Coded Value

This is a value that is set once at design time and doesnt require any run-time evaluation.

Entitlements: Default Access Level

Fork Fork

In this example we set the Default Entitlement to Hidden, so most Modules are not available
We override Layout and FormatColum to be ReadOnly - so users can see the Format Columns and can switch between Layouts - but not edit them
We override SettingsPanel and Dashboard to Full - so they are fully viewable and usable

See how the Default Entitlement is provided

entitlementOptions: {
  defaultAccessLevel: 'Hidden',
  moduleEntitlements: [
    {
      adaptableModule: 'FormatColumn',
      accessLevel: 'ReadOnly',
    },
    {
      adaptableModule: 'Layout',
      accessLevel: 'ReadOnly',
    },
    {
      adaptableModule: 'SettingsPanel',
      accessLevel: 'Full',
    },
    {
      adaptableModule: 'Dashboard',
      accessLevel: 'Full',
    },
  ],
},

import {AdaptableOptions} from '@adaptabletools/adaptable';
import {WebFramework} from './rowData';

export const adaptableOptions: AdaptableOptions<WebFramework> = {
  primaryKey: 'id',
  adaptableId: 'Default Entitlement By Value',

  entitlementOptions: {
    defaultAccessLevel: 'Hidden',
    moduleEntitlements: [
      {
        adaptableModule: 'FormatColumn',
        accessLevel: 'ReadOnly',
      },
      {
        adaptableModule: 'Layout',
        accessLevel: 'ReadOnly',
      },
      {
        adaptableModule: 'SettingsPanel',
        accessLevel: 'Full',
      },
      {
        adaptableModule: 'Dashboard',
        accessLevel: 'Full',
      },
    ],
  },

  initialState: {
    Dashboard: {
      Tabs: [
        {
          Name: 'Demo',
          Toolbars: ['Layout'],
        },
      ],
      ModuleButtons: ['FormatColumn', 'SettingsPanel'],
    },
    Theme: {CurrentTheme: 'dark'},
    FormatColumn: {
      FormatColumns: [
        {
          Name: 'formatColumn-week_issue_change-positive',
          Style: {
            ForeColor: 'Green',
          },
          Scope: {
            ColumnIds: ['week_issue_change'],
          },
          Rule: {
            Predicates: [
              {
                PredicateId: 'Positive',
              },
            ],
          },
        },
        {
          Name: 'formatColumn-week_issue_change-negative',
          Style: {
            ForeColor: 'Red',
          },
          Scope: {
            ColumnIds: ['week_issue_change'],
          },
          Rule: {
            Predicates: [
              {
                PredicateId: 'Negative',
              },
            ],
          },
        },
        {
          Name: 'formatColumn-all',
          Style: {
            BackColor: '#00ffff',
            ForeColor: 'Brown',
          },
          Scope: {
            All: true,
          },
          Rule: {
            BooleanExpression: '[language] = "HTML"',
          },
        },
      ],
    },
    Layout: {
      CurrentLayout: 'Standard Layout',
      Layouts: [
        {
          TableColumns: [
            'name',
            'language',
            'week_issue_change',
            'github_stars',
            'topics',
            'license',
            'created_at',
            'has_wiki',
            'updated_at',
            'pushed_at',
            'github_watchers',
            'description',
            'open_issues_count',
            'closed_issues_count',
            'open_pr_count',
            'closed_pr_count',
            'has_projects',
            'has_pages',
          ],
          Name: 'Standard Layout',
          AutoSizeColumns: true,
        },
        {
          TableColumns: [
            'name',
            'week_issue_change',
            'license',
            'open_issues_count',
            'updated_at',
          ],
          Name: 'Grouped Layout',
          RowGroupedColumns: ['language'],
          TableAggregationColumns: [
            {
              ColumnId: 'open_issues_count',
              AggFunc: 'sum',
            },
            {
              ColumnId: 'week_issue_change',
              AggFunc: 'sum',
            },
          ],
        },
      ],
    },
  },
};

JavaScript Function

The other way to set the Default Access Level is via a Function.

This receives a DefaultAccessLevelContext object (which contains the username and the adaptableId of the current instance) and returns an AccessLevel.

This allows you to provide a different Default Access Level depending on the User's role.

export default {
// Set default Module Entitlement as 'Full' for Admins and 'ReadOnly' for everyone else
const adaptableOptions: AdaptableOptions = {
 entitlementOptions: {
   defaultAccessLevel: (accessLevelContext: DefaultAccessLevelContext)=>{
      return (mockEntitlementService.isAdmin(accessLevelContext.userName))? 'Full': 'ReadOnly';
    },
 },
};

Hint

If defaultAccessLevel is set to Hidden, make sure to enable the Settings Panel for access to AdapTable functionality

PreviousPermissioning Objects NextTechnical Reference

Framework: