@adaptabletools/adaptable 10.0.4-canary.2 → 11.0.0-canary.0

package/src/Strategy/Interface/IModule.d.ts

@@ -1,3 +1,4 @@
+/// <reference types="react" />
 import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
 import { AdaptableMenuItem, ContextMenuContext } from '../../PredefinedConfig/Common/Menu';
 import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
@@ -6,6 +7,9 @@ import { AdaptableObject } from '../../PredefinedConfig/Common/AdaptableObject';
 import { AccessLevel } from '../../PredefinedConfig/Common/Entitlement';
 import { CalculatedColumn } from '../../PredefinedConfig/CalculatedColumnState';
 import { FreeTextColumn } from '../../PredefinedConfig/FreeTextColumnState';
+import { AdaptableOnePageWizardProps } from '../../View/Wizard/Interface/IAdaptableWizard';
+import * as Redux from 'redux';
+import { SuspendableObject } from '../../../types';
 /**
  * This is the interface that all Moduless implement (as well as all deriving from AdaptableModulesBase).
  * Each Module is responsible for creating popup and context menu items, providing an entitlement ( the default is 'Default') and initialising with Redux
@@ -14,7 +18,6 @@ import { FreeTextColumn } from '../../PredefinedConfig/FreeTextColumnState';
  * Application
  * GridInfo
  * StateManagement
- * Piechart
  * TeamSharing
  */
 export interface ModuleInfo {
@@ -30,6 +33,69 @@ export declare type TeamSharingReference = {
     Module: Extract<AdaptableModule, 'CalculatedColumn' | 'FreeTextColumn' | 'Query'>;
     Reference: AdaptableObject;
 };
+export interface AdaptableObjectItemView {
+    /**
+     * Should match property in wizard.
+     * Used to Link to wizard edit step.
+     */
+    name: string;
+    /**
+     * Custom name for the property name
+     */
+    label?: string;
+    /**
+     * How the item is rendered.
+     * Defaults to tags.
+     * Important to be a component so react can detect if it is the same component.
+     */
+    view?: React.FunctionComponent<{
+        data: AdaptableObject | SuspendableObject;
+    }>;
+    /**
+     * Values used for the component.
+     * Could be later extended to include an 'onChange' prop.
+     */
+    values?: (string | number)[];
+}
+export interface AdaptableObjectView {
+    /**
+     * Represents a description row for each adaptable object property.
+     */
+    items: AdaptableObjectItemView[];
+    /**
+     * Used to render expanded content
+     */
+    expand?: React.FunctionComponent;
+    /**
+     * Reference to the underling object.
+     */
+    abObject: AdaptableObject;
+}
+export interface AdaptableModuleView {
+    /**
+     * List of actions.
+     * Allows to add custmo actions.
+     */
+    actions?: React.FunctionComponent<{
+        data: AdaptableObject;
+    }>[];
+    getDeleteAction?: (abObject: AdaptableObject) => Redux.Action;
+    getSuspendAction?: (abObject: AdaptableObject) => Redux.Action;
+    getUnSuspendAction?: (abObject: AdaptableObject) => Redux.Action;
+    emptyView?: React.FunctionComponent<{
+        module: IModule;
+    }> | string;
+    /**
+     * Specifieds the types of objects the module manages.
+     * When specified the new button will have these options.
+     */
+    abObjectTypes?: {
+        name: string;
+        label?: string;
+        accessLevel?: AccessLevel;
+    }[];
+    getEditWizard?(abObject?: AdaptableObject): React.FunctionComponent<AdaptableOnePageWizardProps<AdaptableObject>>;
+}
 export interface IModule {
     moduleInfo: ModuleInfo;
     AccessLevel: AccessLevel;
@@ -47,6 +113,9 @@ export interface IModule {
     getModuleFreeTextColumnReferences(): FreeTextColumn[];
     getPopupMaxWidth(): number | undefined;
     updateOldConfig(): void;
+    toView?: (abObject: AdaptableObject) => AdaptableObjectView;
+    toViewAll?: () => AdaptableObjectView[];
+    getViewProperties?: () => AdaptableModuleView;
 }
 /**
  * A Wrapper around the Modules

package/src/Strategy/LayoutModule.js

@@ -36,6 +36,7 @@ class LayoutModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         });
     }
     addColumnMenuItems(column) {
+        var _a, _b;
         let returnColumnMenuItems = [];
         if (this.isModuleEditable()) {
             const isReadOnlyLayout = this.api.layoutApi.isCurrentLayoutReadOnly();
@@ -62,9 +63,20 @@ class LayoutModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             }
             let selectMenuItems = [];
             if (column) {
-                selectMenuItems.push(this.createColumnMenuItemClickFunction('Column', 'column-chooser', () => {
-                    this.api.columnApi.selectColumn(column.columnId);
-                }));
+                const hasExistingSelection = (_b = (_a = this.api.gridApi.getSelectedCellInfo()) === null || _a === void 0 ? void 0 : _a.gridCells) === null || _b === void 0 ? void 0 : _b.length;
+                if (hasExistingSelection) {
+                    selectMenuItems.push(this.createColumnMenuItemClickFunction('Column (Preserve Selection)', 'column-add', () => {
+                        this.api.columnApi.addColumnToSelection(column.columnId);
+                    }));
+                    selectMenuItems.push(this.createColumnMenuItemClickFunction('Column (Reset Selection)', 'column-chooser', () => {
+                        this.api.columnApi.selectColumn(column.columnId);
+                    }));
+                }
+                else {
+                    selectMenuItems.push(this.createColumnMenuItemClickFunction('Column', 'column-chooser', () => {
+                        this.api.columnApi.selectColumn(column.columnId);
+                    }));
+                }
             }
             selectMenuItems.push(this.createColumnMenuItemClickFunction('Whole Grid', this.moduleInfo.Glyph, () => {
                 this.api.gridApi.selectAll();

package/src/Strategy/PlusMinusModule.d.ts

@@ -1,12 +1,15 @@
+/// <reference types="react" />
 import { AdaptableApi } from '../Api/AdaptableApi';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
 import { AdaptableMenuItem } from '../PredefinedConfig/Common/Menu';
 import { PlusMinusNudge } from '../PredefinedConfig/PlusMinusState';
 import { GridCell } from '../PredefinedConfig/Selection/GridCell';
 import { TeamSharingImportInfo } from '../PredefinedConfig/TeamSharingState';
+import * as PlusMinusRedux from '../Redux/ActionsReducers/PlusMinusRedux';
 import { AdaptableModuleBase } from './AdaptableModuleBase';
 import { IPlusMinusModule } from './Interface/IPlusMinusModule';
 import { AdaptableObject } from '../PredefinedConfig/Common/AdaptableObject';
+import { AdaptableObjectView } from './Interface/IModule';
 export declare class PlusMinusModule extends AdaptableModuleBase implements IPlusMinusModule {
     private shouldHandleKeyDown;
     private adaptable;
@@ -23,4 +26,12 @@ export declare class PlusMinusModule extends AdaptableModuleBase implements IPlu
     private evaluateExpression;
     private ShowErrorPreventMessage;
     getTeamSharingAction(): TeamSharingImportInfo<PlusMinusNudge>;
+    toView(plusMinus: PlusMinusNudge): AdaptableObjectView;
+    toViewAll(): AdaptableObjectView[];
+    getViewProperties(): {
+        getDeleteAction: (plusMinusNudge: PlusMinusNudge) => PlusMinusRedux.PlusMinusNudgeDeleteAction;
+        getSuspendAction: (plusMinusNudge: PlusMinusNudge) => PlusMinusRedux.PlusMinusNudgeSuspendAction;
+        getUnSuspendAction: (plusMinusNudge: PlusMinusNudge) => PlusMinusRedux.PlusMinusNudgeUnSuspendAction;
+        getEditWizard(): import("react").FunctionComponent<import("../View/PlusMinus/Wizard/PlusMinusWizard").PlusMinusWizardProps>;
+    };
 }

package/src/Strategy/PlusMinusModule.js

@@ -9,6 +9,9 @@ const ArrayExtensions_1 = require("../Utilities/Extensions/ArrayExtensions");
 const Helper_1 = require("../Utilities/Helpers/Helper");
 const AdaptableModuleBase_1 = require("./AdaptableModuleBase");
 const ModuleConstants_1 = require("../Utilities/Constants/ModuleConstants");
+const getScopeViewItems_1 = require("./Utilities/getScopeViewItems");
+const PlusMinusWizard_1 = require("../View/PlusMinus/Wizard/PlusMinusWizard");
+const getRuleViewItems_1 = require("./Utilities/getRuleViewItems");
 class PlusMinusModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.PlusMinusModuleId, 'Plus Minus', 'plus-minus', 'PlusMinusPopup', 'Configure how a cell value will edit when the + or - keys are pressed', api);
@@ -179,5 +182,36 @@ class PlusMinusModule extends AdaptableModuleBase_1.AdaptableModuleBase {
             EditAction: PlusMinusRedux.PlusMinusNudgeEdit,
         };
     }
+    toView(plusMinus) {
+        return {
+            abObject: plusMinus,
+            items: [
+                Object.assign({ name: 'Target' }, getScopeViewItems_1.getScopeViewItems(plusMinus.Scope)),
+                plusMinus.Rule && {
+                    name: 'Settings',
+                    label: 'Rule',
+                    values: getRuleViewItems_1.getRuleViewItems(plusMinus.Rule, this.api).values,
+                },
+                {
+                    name: 'Settings',
+                    label: 'Nudge Value',
+                    values: [plusMinus.NudgeValue],
+                },
+            ].filter(Boolean),
+        };
+    }
+    toViewAll() {
+        return this.getModuleAdaptableObjects().map((plusMinus) => this.toView(plusMinus));
+    }
+    getViewProperties() {
+        return {
+            getDeleteAction: PlusMinusRedux.PlusMinusNudgeDelete,
+            getSuspendAction: PlusMinusRedux.PlusMinusNudgeSuspend,
+            getUnSuspendAction: PlusMinusRedux.PlusMinusNudgeUnSuspend,
+            getEditWizard() {
+                return PlusMinusWizard_1.PlusMinusWizard;
+            },
+        };
+    }
 }
 exports.PlusMinusModule = PlusMinusModule;

package/src/Strategy/QueryModule.d.ts

@@ -1,13 +1,33 @@
 import { AdaptableModuleBase } from './AdaptableModuleBase';
+import * as QueryRedux from '../Redux/ActionsReducers/QueryRedux';
 import { TeamSharingImportInfo } from '../PredefinedConfig/TeamSharingState';
 import { NamedQuery } from '../PredefinedConfig/QueryState';
 import { IModule } from './Interface/IModule';
 import { AdaptableApi } from '../Api/AdaptableApi';
 import { AdaptableObject } from '../PredefinedConfig/Common/AdaptableObject';
+import { NamedQueryWizard } from '../View/Query/Wizard/NamedQueryWizard';
 export declare class QueryModule extends AdaptableModuleBase implements IModule {
     constructor(api: AdaptableApi);
     getModuleAdaptableObjects(): AdaptableObject[];
     getTeamSharingAction(): TeamSharingImportInfo<NamedQuery>;
     getExplicitlyReferencedColumnIds(namedQuery: NamedQuery): string[];
     getReferencedNamedQueryNames(namedQuery: NamedQuery): string[];
+    toView(query: NamedQuery): {
+        abObject: NamedQuery;
+        items: {
+            name: string;
+            values: string[];
+        }[];
+    };
+    toViewAll(): {
+        abObject: NamedQuery;
+        items: {
+            name: string;
+            values: string[];
+        }[];
+    }[];
+    getViewProperties(): {
+        getDeleteAction: (namedQuery: NamedQuery) => QueryRedux.NamedQueryDeleteAction;
+        getEditWizard: () => typeof NamedQueryWizard;
+    };
 }

package/src/Strategy/QueryModule.js

@@ -5,6 +5,7 @@ const tslib_1 = require("tslib");
 const AdaptableModuleBase_1 = require("./AdaptableModuleBase");
 const ModuleConstants = tslib_1.__importStar(require("../Utilities/Constants/ModuleConstants"));
 const QueryRedux = tslib_1.__importStar(require("../Redux/ActionsReducers/QueryRedux"));
+const NamedQueryWizard_1 = require("../View/Query/Wizard/NamedQueryWizard");
 class QueryModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.QueryModuleId, 'Query', 'query', 'QueryPopup', 'Run real-time text-based queries using a wealth of powerful functions and operators', api);
@@ -25,5 +26,29 @@ class QueryModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     getReferencedNamedQueryNames(namedQuery) {
         return this.api.queryApi.getReferencedNamedQueryNames(namedQuery.BooleanExpression);
     }
+    toView(query) {
+        return {
+            abObject: query,
+            items: [
+                {
+                    name: 'Query Name',
+                    values: [query.Name],
+                },
+                {
+                    name: 'Expression',
+                    values: [query.BooleanExpression],
+                },
+            ],
+        };
+    }
+    toViewAll() {
+        return this.getModuleAdaptableObjects().map((query) => this.toView(query));
+    }
+    getViewProperties() {
+        return {
+            getDeleteAction: QueryRedux.NamedQueryDelete,
+            getEditWizard: () => NamedQueryWizard_1.NamedQueryWizard,
+        };
+    }
 }
 exports.QueryModule = QueryModule;

package/src/Strategy/ScheduleModule.d.ts

@@ -1,6 +1,9 @@
+/// <reference types="react" />
 import { AdaptableModuleBase } from './AdaptableModuleBase';
-import { IModule } from './Interface/IModule';
+import { AdaptableObjectView, IModule } from './Interface/IModule';
 import { AdaptableApi } from '../Api/AdaptableApi';
+import { BaseSchedule } from '../PredefinedConfig/Common/Schedule';
+import * as ScheduleRedux from '../Redux/ActionsReducers/ScheduleRedux';
 export declare class ScheduleModule extends AdaptableModuleBase implements IModule {
     private scheduleJobs;
     constructor(api: AdaptableApi);
@@ -10,4 +13,17 @@ export declare class ScheduleModule extends AdaptableModuleBase implements IModu
     private addMidnightRefreshSchedule;
     private getDateFromSchedule;
     private clearAllJobs;
+    getModuleAdaptableObjects(): BaseSchedule[];
+    toView(schedule: BaseSchedule): AdaptableObjectView;
+    toViewAll(): AdaptableObjectView[];
+    getViewProperties(): {
+        abObjectTypes: {
+            name: string;
+            accessLevel: import("../types").AccessLevel;
+        }[];
+        getDeleteAction: (schedule: BaseSchedule) => ScheduleRedux.Glue42ScheduleDeleteAction | ScheduleRedux.OpenFinScheduleDeleteAction | ScheduleRedux.IPushPullScheduleDeleteAction | ScheduleRedux.ReminderScheduleDeleteAction | ScheduleRedux.ReportScheduleDeleteAction;
+        getSuspendAction: (schedule: BaseSchedule) => ScheduleRedux.Glue42ScheduleSuspendAction | ScheduleRedux.OpenFinScheduleSuspendAction | ScheduleRedux.IPushPullScheduleSuspendAction | ScheduleRedux.ReminderScheduleSuspendAction | ScheduleRedux.ReportScheduleSuspendAction;
+        getUnSuspendAction: (schedule: BaseSchedule) => ScheduleRedux.Glue42ScheduleUnSuspendAction | ScheduleRedux.OpenFinScheduleUnSuspendAction | ScheduleRedux.IPushPullScheduleUnSuspendAction | ScheduleRedux.ReminderScheduleUnSuspendAction | ScheduleRedux.ReportScheduleUnSuspendAction;
+        getEditWizard(): import("react").FunctionComponent<import("../View/Schedule/Wizard/ScheduleWizard").ScheduleWizardProps>;
+    };
 }

package/src/Strategy/ScheduleModule.js

@@ -6,6 +6,10 @@ const AdaptableModuleBase_1 = require("./AdaptableModuleBase");
 const ModuleConstants = tslib_1.__importStar(require("../Utilities/Constants/ModuleConstants"));
 const Enums_1 = require("../PredefinedConfig/Common/Enums");
 const ArrayExtensions_1 = tslib_1.__importDefault(require("../Utilities/Extensions/ArrayExtensions"));
+const ScheduleWizard_1 = require("../View/Schedule/Wizard/ScheduleWizard");
+const ScheduleSettingsSummary_1 = require("../View/Schedule/Wizard/ScheduleSettingsWizard/ScheduleSettingsSummary");
+const UIHelper_1 = tslib_1.__importDefault(require("../View/UIHelper"));
+const ScheduleRedux = tslib_1.__importStar(require("../Redux/ActionsReducers/ScheduleRedux"));
 const dateTimeouts = {};
 const NodeSchedule = {
     scheduleJob: (date, fn) => {
@@ -77,7 +81,7 @@ class ScheduleModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         const reloadSchedule = {
             Hour: 0,
             Minute: 1,
-            DaysOfWeek: [0, 1, 2, 3, 4, 5, 6],
+            DaysOfWeek: ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday'],
         };
         const date = this.getDateFromSchedule(reloadSchedule);
         if (date != null) {
@@ -93,7 +97,7 @@ class ScheduleModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         }
         else {
             date = new Date();
-            if (ArrayExtensions_1.default.ContainsItem(schedule.DaysOfWeek, date.getDay())) {
+            if (ArrayExtensions_1.default.ContainsItem(schedule.DaysOfWeek, UIHelper_1.default.getWeekDayByIndex(date.getDay()))) {
                 date.setHours(schedule.Hour);
                 date.setMinutes(schedule.Minute);
                 date.setSeconds(0);
@@ -116,5 +120,147 @@ class ScheduleModule extends AdaptableModuleBase_1.AdaptableModuleBase {
         });
         this.scheduleJobs = [];
     }
+    getModuleAdaptableObjects() {
+        const entitlementService = this.api.internalApi.getEntitlementService();
+        const accessLevel = entitlementService.getEntitlementAccessLevelForModule(this.moduleInfo.ModuleName);
+        const exportAcessLevel = entitlementService.getEntitlementAccessLevelForModule(ModuleConstants.ExportModuleId);
+        let allSchedules = [];
+        if (accessLevel !== 'Hidden') {
+            allSchedules.push(...this.api.scheduleApi.getAllReminderSchedule());
+        }
+        if (exportAcessLevel !== 'Hidden') {
+            allSchedules.push(...this.api.scheduleApi.getAllReportSchedule());
+        }
+        allSchedules.push(...this.api.scheduleApi.getAllIPushPullSchedule());
+        allSchedules.push(...this.api.scheduleApi.getAllGlue42Schedule());
+        allSchedules.push(...this.api.scheduleApi.getAllOpenFinSchedule());
+        return allSchedules;
+    }
+    toView(schedule) {
+        return {
+            abObject: schedule,
+            items: [
+                {
+                    name: 'Settings',
+                    values: ScheduleSettingsSummary_1.getScheduleSettingsValues(schedule).map((description) => `${description.label}: ${description.value}`),
+                },
+                {
+                    name: 'Schedule',
+                    values: [UIHelper_1.default.getScheduleDescription(schedule.Schedule)],
+                },
+            ],
+        };
+    }
+    toViewAll() {
+        return this.getModuleAdaptableObjects().map((schedule) => this.toView(schedule));
+    }
+    getViewProperties() {
+        const entitlementService = this.api.internalApi.getEntitlementService();
+        const accessLevel = entitlementService.getEntitlementAccessLevelForModule(this.moduleInfo.ModuleName);
+        const exportAcessLevel = entitlementService.getEntitlementAccessLevelForModule(ModuleConstants.ExportModuleId);
+        const abObjectTypes = [];
+        const ippApi = this.api.pluginsApi.getipushpullPluginApi();
+        const glue42Api = this.api.pluginsApi.getGlue42PluginApi();
+        const openFinApi = this.api.pluginsApi.getOpenFinPluginApi();
+        if (accessLevel !== 'Hidden') {
+            abObjectTypes.push({
+                name: 'Reminder',
+                accessLevel,
+            });
+        }
+        if (exportAcessLevel !== 'Hidden') {
+            abObjectTypes.push({
+                name: 'Report',
+                accessLevel: exportAcessLevel,
+            });
+        }
+        if (ippApi && ippApi.isIPushPullRunning()) {
+            abObjectTypes.push({
+                name: 'ipushpull',
+                accessLevel,
+            });
+        }
+        if (glue42Api && glue42Api.isGlue42Running()) {
+            abObjectTypes.push({
+                name: 'Glue42',
+                accessLevel,
+            });
+        }
+        if (openFinApi && openFinApi.isOpenFinRunning()) {
+            abObjectTypes.push({
+                name: 'OpenFin',
+                accessLevel,
+            });
+        }
+        return {
+            abObjectTypes,
+            getDeleteAction: (schedule) => {
+                let deleteAction = null;
+                switch (schedule.ScheduleType) {
+                    case Enums_1.ScheduleType.Reminder:
+                        deleteAction = ScheduleRedux.ReminderScheduleDelete(schedule);
+                        break;
+                    case Enums_1.ScheduleType.Report:
+                        deleteAction = ScheduleRedux.ReportScheduleDelete(schedule);
+                        break;
+                    case Enums_1.ScheduleType.ipushpull:
+                        deleteAction = ScheduleRedux.IPushPullScheduleDelete(schedule);
+                        break;
+                    case Enums_1.ScheduleType.Glue42:
+                        deleteAction = ScheduleRedux.Glue42ScheduleDelete(schedule);
+                        break;
+                    case Enums_1.ScheduleType.OpenFin:
+                        deleteAction = ScheduleRedux.OpenFinScheduleDelete(schedule);
+                        break;
+                }
+                return deleteAction;
+            },
+            getSuspendAction: (schedule) => {
+                let suspendAction = null;
+                switch (schedule.ScheduleType) {
+                    case Enums_1.ScheduleType.Reminder:
+                        suspendAction = ScheduleRedux.ReminderScheduleSuspend(schedule);
+                        break;
+                    case Enums_1.ScheduleType.Report:
+                        suspendAction = ScheduleRedux.ReportScheduleSuspend(schedule);
+                        break;
+                    case Enums_1.ScheduleType.ipushpull:
+                        suspendAction = ScheduleRedux.IPushPullScheduleSuspend(schedule);
+                        break;
+                    case Enums_1.ScheduleType.Glue42:
+                        suspendAction = ScheduleRedux.Glue42ScheduleSuspend(schedule);
+                        break;
+                    case Enums_1.ScheduleType.OpenFin:
+                        suspendAction = ScheduleRedux.OpenFinScheduleSuspend(schedule);
+                        break;
+                }
+                return suspendAction;
+            },
+            getUnSuspendAction: (schedule) => {
+                let unSuspendAction = null;
+                switch (schedule.ScheduleType) {
+                    case Enums_1.ScheduleType.Reminder:
+                        unSuspendAction = ScheduleRedux.ReminderScheduleUnSuspend(schedule);
+                        break;
+                    case Enums_1.ScheduleType.Report:
+                        unSuspendAction = ScheduleRedux.ReportScheduleUnSuspend(schedule);
+                        break;
+                    case Enums_1.ScheduleType.ipushpull:
+                        unSuspendAction = ScheduleRedux.IPushPullScheduleUnSuspend(schedule);
+                        break;
+                    case Enums_1.ScheduleType.Glue42:
+                        unSuspendAction = ScheduleRedux.Glue42ScheduleUnSuspend(schedule);
+                        break;
+                    case Enums_1.ScheduleType.OpenFin:
+                        unSuspendAction = ScheduleRedux.OpenFinScheduleUnSuspend(schedule);
+                        break;
+                }
+                return unSuspendAction;
+            },
+            getEditWizard() {
+                return ScheduleWizard_1.ScheduleWizard;
+            },
+        };
+    }
 }
 exports.ScheduleModule = ScheduleModule;

package/src/Strategy/SetingsPanelModule.d.ts

@@ -0,0 +1,11 @@
+import { AdaptableApi } from '../Api/AdaptableApi';
+import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
+import { AdaptableMenuItem, ContextMenuContext } from '../PredefinedConfig/Common/Menu';
+import { AdaptableModuleBase } from './AdaptableModuleBase';
+import { IModule } from './Interface/IModule';
+export declare class SettingsPanelModule extends AdaptableModuleBase implements IModule {
+    constructor(api: AdaptableApi);
+    addColumnMenuItems(column: AdaptableColumn): AdaptableMenuItem[] | undefined;
+    addContextMenuItems(menuContext: ContextMenuContext): AdaptableMenuItem[] | undefined;
+    addModuleMenuItem(source: 'ModuleMenu' | 'ModuleButton'): AdaptableMenuItem | undefined;
+}

package/src/Strategy/SetingsPanelModule.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SettingsPanelModule = void 0;
+const tslib_1 = require("tslib");
+const ModuleConstants = tslib_1.__importStar(require("../Utilities/Constants/ModuleConstants"));
+const AdaptableModuleBase_1 = require("./AdaptableModuleBase");
+const PopupRedux = tslib_1.__importStar(require("../Redux/ActionsReducers/PopupRedux"));
+class SettingsPanelModule extends AdaptableModuleBase_1.AdaptableModuleBase {
+    constructor(api) {
+        const friendlyName = api.internalApi.getAdaptableOptions().settingsPanelOptions.title;
+        super(ModuleConstants.SettingsPanelModuleId, friendlyName, 'settings', null, 'Manage all Adaptable Settings', api);
+    }
+    addColumnMenuItems(column) {
+        return [
+            // To do : get the icon and name from settings in case they have changed?
+            this.createColumnMenuItemReduxAction('Open ' + this.moduleInfo.FriendlyName, this.moduleInfo.Glyph, PopupRedux.PopupShowScreen()),
+        ];
+    }
+    addContextMenuItems(menuContext) {
+        return [
+            this.createColumnMenuItemReduxAction('Open ' + this.moduleInfo.FriendlyName, this.moduleInfo.Glyph, PopupRedux.PopupShowScreen()),
+        ];
+    }
+    addModuleMenuItem(source) {
+        if (this.isModuleAvailable()) {
+            return this.createColumnMenuItemReduxAction('Open ' + this.moduleInfo.FriendlyName, this.moduleInfo.Glyph, PopupRedux.PopupShowScreen());
+        }
+    }
+}
+exports.SettingsPanelModule = SettingsPanelModule;

package/src/Strategy/ShortcutModule.d.ts

@@ -1,9 +1,12 @@
+/// <reference types="react" />
 import { AdaptableModuleBase } from './AdaptableModuleBase';
+import * as ShortcutRedux from '../Redux/ActionsReducers/ShortcutRedux';
 import { Shortcut } from '../PredefinedConfig/ShortcutState';
 import { TeamSharingImportInfo } from '../PredefinedConfig/TeamSharingState';
 import { IShortcutModule } from './Interface/IShortcutModule';
 import { AdaptableApi } from '../Api/AdaptableApi';
 import { AdaptableObject } from '../PredefinedConfig/Common/AdaptableObject';
+import { AdaptableObjectView } from './Interface/IModule';
 export declare class ShortcutModule extends AdaptableModuleBase implements IShortcutModule {
     private shouldHandleKeyDown;
     private adaptable;
@@ -15,4 +18,12 @@ export declare class ShortcutModule extends AdaptableModuleBase implements IShor
     checkListenToKeyDown(): void;
     private handleKeyDown;
     private calculateShortcut;
+    toView(shortcut: Shortcut): AdaptableObjectView;
+    toViewAll(): AdaptableObjectView[];
+    getViewProperties(): {
+        getDeleteAction: (shortcut: Shortcut) => ShortcutRedux.ShortcutDeleteAction;
+        getSuspendAction: (shortcut: Shortcut) => ShortcutRedux.ShortcutDeleteAction;
+        getUnSuspendAction: (shortcut: Shortcut) => ShortcutRedux.ShortcutDeleteAction;
+        getEditWizard(): import("react").FunctionComponent<import("../View/Shortcut/Wizard/ShortcutWizard").ShortcutWizardProps>;
+    };
 }

package/src/Strategy/ShortcutModule.js

@@ -8,6 +8,9 @@ const ShortcutRedux = tslib_1.__importStar(require("../Redux/ActionsReducers/Sho
 const Enums_1 = require("../PredefinedConfig/Common/Enums");
 const ArrayExtensions_1 = require("../Utilities/Extensions/ArrayExtensions");
 const StringExtensions_1 = tslib_1.__importDefault(require("../Utilities/Extensions/StringExtensions"));
+const ShortcutWizard_1 = require("../View/Shortcut/Wizard/ShortcutWizard");
+const getScopeViewItems_1 = require("./Utilities/getScopeViewItems");
+const getShortcutSettingsViewItems_1 = require("./Utilities/getShortcutSettingsViewItems");
 class ShortcutModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {
         super(ModuleConstants.ShortcutModuleId, 'Shortcut', 'shortcut', 'ShortcutPopup', 'Set up rules so cells update mathematically when keys are pressed in numeric cells', api);
@@ -68,5 +71,24 @@ class ShortcutModule extends AdaptableModuleBase_1.AdaptableModuleBase {
                 return firstNumber / secondNumber;
         }
     }
+    toView(shortcut) {
+        return {
+            abObject: shortcut,
+            items: [getScopeViewItems_1.getScopeViewItems(shortcut.Scope), getShortcutSettingsViewItems_1.getShortcutSettingsViewItems(shortcut)],
+        };
+    }
+    toViewAll() {
+        return this.getModuleAdaptableObjects().map((shortcut) => this.toView(shortcut));
+    }
+    getViewProperties() {
+        return {
+            getDeleteAction: ShortcutRedux.ShortcutDelete,
+            getSuspendAction: ShortcutRedux.ShortcutSuspend,
+            getUnSuspendAction: ShortcutRedux.ShortcutUnSuspend,
+            getEditWizard() {
+                return ShortcutWizard_1.ShortcutWizard;
+            },
+        };
+    }
 }
 exports.ShortcutModule = ShortcutModule;

package/src/Strategy/ToolPanelModule.js

@@ -9,7 +9,7 @@ const ToolPanelRedux_1 = require("../Redux/ActionsReducers/ToolPanelRedux");
 const LoggingHelper_1 = require("../Utilities/Helpers/LoggingHelper");
 class ToolPanelModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     constructor(api) {
-        super(ModuleConstants.ToolPanelModuleId, 'Tool Panel', 'state-management', 'ToolPanelPopup', 'An alternative to using the Dashboard is the AdapTable Tool Panel, the Tool Panel is the collapsible area to the right of the Grid.', api);
+        super(ModuleConstants.ToolPanelModuleId, 'Tool Panel', 'tool-panel', 'ToolPanelPopup', 'An alternative to using the Dashboard is the AdapTable Tool Panel, the Tool Panel is the collapsible area to the right of the Grid.', api);
     }
     isModuleAvailable() {
         if (!super.isModuleAvailable()) {

package/src/Strategy/Utilities/getAlertBehaviourViewItems.d.ts

@@ -0,0 +1,8 @@
+import * as React from 'react';
+import { AlertDefinition } from '../../../types';
+export declare const getAlertBehaviourViewItems: () => {
+    name: string;
+    view: React.FunctionComponent<{
+        data: AlertDefinition;
+    }>;
+};

package/src/Strategy/Utilities/getAlertBehaviourViewItems.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAlertBehaviourViewItems = void 0;
+const AdaptableContext_1 = require("../../View/AdaptableContext");
+const AlertBehaviourWizardSection_1 = require("../../View/Alert/Wizard/AlertBehaviourWizardSection");
+const BehaviourView = (props) => {
+    const adaptable = AdaptableContext_1.useAdaptable();
+    return AlertBehaviourWizardSection_1.renderAlertBehaviourSummary(props.data, adaptable.api, true);
+};
+exports.getAlertBehaviourViewItems = () => {
+    return {
+        name: 'Behaviour',
+        view: BehaviourView,
+    };
+};

package/src/Strategy/Utilities/getAlertPreviewViewItems.d.ts

@@ -0,0 +1,4 @@
+import { AdaptableApi } from '../../../types';
+import { AlertDefinition } from '../../PredefinedConfig/AlertState';
+import { AdaptableObjectItemView } from '../Interface/IModule';
+export declare const getAlertPreviewViewItems: (alert: AlertDefinition, api: AdaptableApi) => AdaptableObjectItemView;

package/src/Strategy/Utilities/getAlertPreviewViewItems.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAlertPreviewViewItems = void 0;
+const tslib_1 = require("tslib");
+const React = tslib_1.__importStar(require("react"));
+const Tag_1 = require("../../components/Tag");
+const AlertDisplayWizardSection_1 = require("../../View/Alert/Wizard/AlertDisplayWizardSection");
+exports.getAlertPreviewViewItems = (alert, api) => {
+    return {
+        name: 'Type and Display',
+        view: () => {
+            var _a;
+            if (!((_a = alert === null || alert === void 0 ? void 0 : alert.AlertProperties) === null || _a === void 0 ? void 0 : _a.DisplayNotification)) {
+                return React.createElement(Tag_1.Tag, null, alert.MessageType);
+            }
+            return React.createElement(AlertDisplayWizardSection_1.AlertPreview, { style: { maxWidth: 400 }, mt: 2, api: api, alertDefinition: alert });
+        },
+    };
+};