Making Notes

Summary

Notes are annotations that are attached to AG Grid Cells
They are designed for per-user user and are stored in AdapTable State

Notes are personal annotations that run-time users attach to individual Cells in AG Grid.

Each Cell can have only one Note attached (but it can be edited).

Notes are stored in Adaptable State, rather than with the Grid’s underlying data source.

Note

Notes differ to Comments as they are for personal use, while Comments enable inter-colleague communication
Notes differ to Free Text Columns as they are attached to a single cell rather than form a new Column

Notes can be created in 2 ways:

by run-time users using the Context Menu and adding Text
by design-time developers through Notes Initial Adaptable State

Caution

Notes are not available if you are using an auto-generated Primary Key

Notes in AdapTable

Fork Fork

This example contains 4 Notes: 2 on the Name Column and 2 on the Licence Column

import {
  AdaptableOptions,
  CustomContextMenuContext,
} from '@adaptabletools/adaptable';
import {WebFramework} from './rowData';
import {
  AdaptableContextMenuItemName,
  AdaptableSystemContextMenuItem,
} from '@adaptabletools/adaptable';

export const adaptableOptions: AdaptableOptions<WebFramework> = {
  primaryKey: 'id',
  adaptableId: 'Notes',
  userName: 'Demo User',
  contextMenuOptions: {
    customContextMenu: (customMenuContext: CustomContextMenuContext) => {
      return customMenuContext.defaultAdaptableMenuStructure
        .filter(
          (
            item
          ): item is AdaptableSystemContextMenuItem<AdaptableContextMenuItemName> =>
            item !== '-'
        )
        .filter(item => item.category === 'Note');
    },
  },
  initialState: {
    Dashboard: {
      ModuleButtons: ['Note'],
    },
    Theme: {CurrentTheme: 'dark'},

    Note: {
      Notes: [
        {
          PrimaryKeyValue: 10270250,
          Text: 'We are using this Framework',
          ColumnId: 'name',
          Timestamp: new Date().setDate(new Date().getDate() - 1),
        },
        {
          PrimaryKeyValue: 11730342,
          Text: 'Popular with the Accounts team',
          ColumnId: 'name',
          Timestamp: new Date().setDate(new Date().getDate() - 2),
        },
        {
          PrimaryKeyValue: 82095231,
          Text: 'Need to find out Stencil license',
          ColumnId: 'license',
          Timestamp: new Date().setDate(new Date().getDate() - 3),
        },
        {
          PrimaryKeyValue: 5532320,
          Text: 'Need to find out Polymer license',
          ColumnId: 'license',
          Timestamp: new Date().setDate(new Date().getDate() - 4),
        },
      ],
    },
    Layout: {
      CurrentLayout: 'Standard Layout',
      Layouts: [
        {
          TableColumns: [
            'name',
            'github_stars',
            'license',
            'github_watchers',
            'language',
            'open_issues_count',
            'closed_issues_count',
            'created_at',
            'has_wiki',
            'updated_at',
            'pushed_at',
            'description',
            'open_pr_count',
            'closed_pr_count',
            'has_projects',
            'has_pages',
            'week_issue_change',
          ],
          Name: 'Standard Layout',
          AutoSizeColumns: true,
        },
      ],
    },
  },
};

Defining Notes

Notes can be defined by developers at run-time using Notes Initial Adaptable State.

Developer Guide

Defining a Note

Each Note object contains 4 properties: the Text, the Column, Primary Key and a Timestamp:

Note: {
  Notes: [
    {
      PrimaryKeyValue: 10270250,
      Text: 'We are using this Framework',
      ColumnId: 'name',
      Timestamp: new Date(),
    },
  ],

Provide Primary Key Value

This is the Primary Key value for the row containing the Note

Supply the Text

The actual contents of the Note

Provide a ColumnId

The Id of the Column that contains the cell

Timestamp (optional)

When the Note was written

Using Notes

Notes can be added by run-time users of AdapTable.

UI Step by Step Guide

Creating Notes in AdapTable

UI Entitlements

The UI Entitlements behaviour for Notes is as expected for Full and Hidden Access Levels.

The ReadOnly Entitlement behaviour is that Notes provided in Initial State will be visible but they cannot be edited nor deleted, and new Notes cannot be added.

FAQ

Can I share my Notes with colleagues through Team Sharing? Technically you can, but for that use case we recommend using Comments which are designed for this purpose.

NextConfiguring Notes

Framework: