AdapTable Version:

Framework:

FDC3 Data Grid Context Mappings

Summary

FDC3 Mappings define which columns / fields should be used for which FDC3 objects
It enables a data-first approach to using FDC3 which is incredibly flexible

Grid Data Mappings provide the "glue" to map AG Grid's data and columns to required FDC3 behaviour.

AdapTable looks at the mappings to work out which columns to use when creating Intents and Contexts.

Breaking Change

Previously AdapTable provided FDC3 Columns which defined which contexts to use
These have been replaced with mappings which allow for a richer and more intuitive "data-first" approach

Mappings are provided in the gridDataContextMapping property of FDC3 Options.

gridDataContextMapping

GridDataContextMapping

Maps Context Type to AdapTable Grid Data

GridDataContextMapping

This property is used to tell AdapTable which columns and fields should be used in FDC3 Context.

These are then used when raising Intents or broadcasting Context.

The GridDataContextMapping object provides the FDC3 Context.

Grid Data Context Mapping

ֵEach Grid Data Context Mapping has the same structure (though the details will differ according to the Context type):

a key - a formal FDC3 type (e.g. fdc3.instrument or fdc3.currency)
an associated FDC3 Context object

The FDC3 Context object contains 2 properties:

name - an FDC3 Data Mapping
id - an object which can contain multiple properties. Each of the properties will provide a FDC3 Data Mapping

FDC3 Data Mapping

Each FDC3 Data Mapping tells AdapTable where to find the data to build the Context.

The Data Mapping can always be one of 2 types of object:

a Column - either AdapTable or AG Grid; using the _colId prefix (e.g. _colId.instrument)
a Field in the Grid's data source; using the _field prefix (e.g. _field.ticker)

gridDataContextMapping: {
  'fdc3.instrument': {
    name: '_colId.instrument',
    id: {
      ticker: '_colId.ticker',
      BBG: '_field.bbgId',
    },
  },
}

Developer Guide

Creating FDC3 Grid Data Mappings

Lets look in more detail at the example above - which uses a fdc3.instrument.

We therefore provide an FDC3 Instrument Context (see formal object definition here) and then reference it to raise Intents and broadcast Contexts.

  gridDataContextMapping: {
    'fdc3.instrument': {
      name: '_colId.instrument',
      id: {
        ticker: '_colId.ticker',
        BBG: '_field.bbgId',
      },
    },

Create the Data Context Mapping

First provide the Mapping using the gridDataContextMapping property

Then define each Mapping as required.

The key is always a FDC3 Context type.

In this example its an Instrument defined as fdc3.instrument

  gridDataContextMapping: {
    'fdc3.instrument': {
      name: '_colId.instrument',
      id: {
        ticker: '_colId.ticker',
        BBG: '_field.bbgId',
      },
    },

And name and id

Each mapping has 2 properties:

name - typically one column
id - an object with multiple properties, each will be a Data Mapping

In this example of fdc3.instrument, the id can include many different properties, and we have provided 2 (ticker and BBG)

  gridDataContextMapping: {
    'fdc3.instrument': {
      name: '_colId.instrument',
      id: {
        ticker: '_colId.ticker',
        BBG: '_field.bbgId',
      },
    },

Map Columns and Fields using Data Mappings

Map Columns or Fields to each Data Mapping as required.

Columns use the prefix _colId - here we reference 2 Columns:

Instrument - which we provide for name property
Ticker - which we provide for the ticker property

Fields in the DataSource use the prefix _field - as in this example:

bbgId - which we provide for the BBG property

 intents: {
  raises: {
    ViewInstrument: [
      {
        contextType: 'fdc3.instrument',
        contextMenu: {
          columnIds: ['ticker'],
        },
        actionButton: {
          id: 'viewInstrumentButton',
          label: 'View Instrument',
        },
      },
    ],
  },
  listensFor: ['ViewQuote', 'ViewInstrument'],
},

Define Intents

Now we can use it to manage Intents. We are able to:

raise the ViewInstrument Intent

Note
We use both Context Menu and Action Column
listen for the ViewQuote Intent

In both cases, AdapTable will automatically use the mapping supplied in Step 1 when providing context.

 contexts: {
  broadcasts: {
    'fdc3.instrument': {
      contextMenu: {
        columnIds: ['ticker'],
      },
      actionButton: {
        id: 'broadCastInstrumentButton',
        label: 'Broadcast Ticker Info',
      },
    },
  },
  listensFor: ['fdc3.instrument'],
},

Define Contexts

Similarly we can use the mapping with Contexts. We are able to:

broadcast Instrument Context

Note
Again, we use both Context Menu and Action Column
listen for the fdc3.instrument context being broadcast in other applications

And, again, AdapTable will automatically use the mapping supplied in Step 1 when providing context.

Available Contexts

The following FDC3 2.0 Contexts can be provided in Grid Data Context Mappings:

Hint

Click the link to see full details of the Context in the FDC3 2.0 documentation

PreviousFDC3 NextFDC3 Contexts