@adaptabletools/adaptable 10.0.4-canary.1 → 10.0.4-canary.5

package/src/Strategy/GridInfoModule.js

@@ -13,13 +13,21 @@ class GridInfoModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     }
     addColumnMenuItems(column) {
         if (this.isModuleAvailable()) {
+            const showGridSection = this.api.internalApi
+                .getEntitlementService()
+                .isGridInfoSectionVisible('GridSummary');
+            const showColumnInfoSection = this.api.internalApi
+                .getEntitlementService()
+                .isGridInfoSectionVisible('ColumnInfo');
             let selectMenuItems = [];
-            selectMenuItems.push(this.createMainMenuItemShowPopup({
-                Label: 'Grid',
-                ComponentName: this.moduleInfo.Popup,
-                Icon: 'align-justify',
-            }));
-            if (column) {
+            if (showGridSection) {
+                selectMenuItems.push(this.createMainMenuItemShowPopup({
+                    Label: 'Grid',
+                    ComponentName: this.moduleInfo.Popup,
+                    Icon: 'align-justify',
+                }));
+            }
+            if (column && showColumnInfoSection) {
                 selectMenuItems.push(this.createMainMenuItemShowPopup({
                     Label: 'Column',
                     ComponentName: this.moduleInfo.Popup,
@@ -30,48 +38,62 @@ class GridInfoModule extends AdaptableModuleBase_1.AdaptableModuleBase {
                     },
                 }));
             }
-            return [
-                {
-                    label: 'Show Info',
-                    isVisible: true,
-                    icon: this.moduleInfo.Glyph,
-                    subItems: selectMenuItems,
-                },
-            ];
+            if (showGridSection || showColumnInfoSection) {
+                return [
+                    {
+                        label: 'Show Info',
+                        isVisible: true,
+                        icon: this.moduleInfo.Glyph,
+                        subItems: selectMenuItems,
+                    },
+                ];
+            }
         }
     }
     addContextMenuItems(menuContext) {
         if (this.isModuleAvailable()) {
             let selectMenuItems = [];
+            const showGridSection = this.api.internalApi
+                .getEntitlementService()
+                .isGridInfoSectionVisible('GridSummary');
+            const showColumnInfoSection = this.api.internalApi
+                .getEntitlementService()
+                .isGridInfoSectionVisible('ColumnInfo');
             let gridPopUpParams = {
                 source: 'ContextMenu',
             };
-            selectMenuItems.push(this.createMainMenuItemShowPopup({
-                Label: 'Grid',
-                ComponentName: this.moduleInfo.Popup,
-                Icon: 'align-justify',
-                PopupParams: gridPopUpParams,
-            }));
-            if (!menuContext.isRowGroupColumn) {
-                let columnPopUpParams = {
-                    source: 'ContextMenu',
-                    column: menuContext.adaptableColumn,
-                };
+            if (showGridSection) {
                 selectMenuItems.push(this.createMainMenuItemShowPopup({
-                    Label: 'Column',
+                    Label: 'Grid',
                     ComponentName: this.moduleInfo.Popup,
-                    Icon: 'column-chooser',
-                    PopupParams: columnPopUpParams,
+                    Icon: 'align-justify',
+                    PopupParams: gridPopUpParams,
                 }));
             }
-            return [
-                {
-                    label: 'Show Info',
-                    isVisible: true,
-                    icon: this.moduleInfo.Glyph,
-                    subItems: selectMenuItems,
-                },
-            ];
+            if (showColumnInfoSection) {
+                if (!menuContext.isRowGroupColumn) {
+                    let columnPopUpParams = {
+                        source: 'ContextMenu',
+                        column: menuContext.adaptableColumn,
+                    };
+                    selectMenuItems.push(this.createMainMenuItemShowPopup({
+                        Label: 'Column',
+                        ComponentName: this.moduleInfo.Popup,
+                        Icon: 'column-chooser',
+                        PopupParams: columnPopUpParams,
+                    }));
+                }
+            }
+            if (showGridSection || showColumnInfoSection) {
+                return [
+                    {
+                        label: 'Show Info',
+                        isVisible: true,
+                        icon: this.moduleInfo.Glyph,
+                        subItems: selectMenuItems,
+                    },
+                ];
+            }
         }
     }
 }

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

@@ -1,11 +1,15 @@
+/// <reference types="react" />
 import { AdaptableColumn } from '../../PredefinedConfig/Common/AdaptableColumn';
-import { AdaptableMenuItem, MenuContext } from '../../PredefinedConfig/Common/Menu';
+import { AdaptableMenuItem, ContextMenuContext } from '../../PredefinedConfig/Common/Menu';
 import { AdaptableModule } from '../../PredefinedConfig/Common/Types';
 import { TeamSharingImportInfo } from '../../PredefinedConfig/TeamSharingState';
 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
@@ -30,12 +34,75 @@ 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;
     addModuleMenuItem(source: 'ModuleMenu' | 'ModuleButton'): AdaptableMenuItem | undefined;
     addColumnMenuItems(column: AdaptableColumn): AdaptableMenuItem[] | undefined;
-    addContextMenuItems(menuContext: MenuContext): AdaptableMenuItem[] | undefined;
+    addContextMenuItems(menuContext: ContextMenuContext): AdaptableMenuItem[] | undefined;
     setModuleEntitlement(): void;
     isModuleAvailable(): boolean;
     isModuleEditable(): boolean;
@@ -47,6 +114,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.d.ts

@@ -1,6 +1,6 @@
 import { AdaptableModuleBase } from './AdaptableModuleBase';
 import { LayoutState, Layout } from '../PredefinedConfig/LayoutState';
-import { AdaptableMenuItem, MenuContext } from '../PredefinedConfig/Common/Menu';
+import { AdaptableMenuItem, ContextMenuContext } from '../PredefinedConfig/Common/Menu';
 import { TeamSharingImportInfo } from '../PredefinedConfig/TeamSharingState';
 import { AdaptableColumn } from '../PredefinedConfig/Common/AdaptableColumn';
 import { AdaptableApi } from '../Api/AdaptableApi';
@@ -14,6 +14,6 @@ export declare class LayoutModule extends AdaptableModuleBase implements IModule
     hasNamedQueryReferences(): boolean;
     handleAdaptableReady(): void;
     addColumnMenuItems(column: AdaptableColumn): AdaptableMenuItem[] | undefined;
-    addContextMenuItems(menuContext: MenuContext): AdaptableMenuItem[] | undefined;
+    addContextMenuItems(menuContext: ContextMenuContext): AdaptableMenuItem[] | undefined;
     getTeamSharingAction(): TeamSharingImportInfo<Layout>;
 }

package/src/Strategy/LayoutModule.js

@@ -38,15 +38,28 @@ class LayoutModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     addColumnMenuItems(column) {
         let returnColumnMenuItems = [];
         if (this.isModuleEditable()) {
-            returnColumnMenuItems.push(this.createColumnMenuItemShowPopup('Edit Layout', this.moduleInfo.Popup, this.moduleInfo.Glyph, {
-                action: 'Edit',
-                source: 'ColumnMenu',
-            }));
-            if (column && column.hideable) {
-                returnColumnMenuItems.push(this.createColumnMenuItemClickFunction('Hide Column', 'hide-column', () => {
-                    this.api.columnApi.hideColumn(column.columnId);
+            const isReadOnlyLayout = this.api.layoutApi.isCurrentLayoutReadOnly();
+            if (!isReadOnlyLayout) {
+                returnColumnMenuItems.push(this.createColumnMenuItemShowPopup('Edit Layout', this.moduleInfo.Popup, this.moduleInfo.Glyph, {
+                    action: 'Edit',
+                    source: 'ColumnMenu',
                 }));
             }
+            if (column) {
+                if (!isReadOnlyLayout) {
+                    returnColumnMenuItems.push(this.createColumnMenuItemClickFunction('Change Caption', 'edit', () => {
+                        let newname = prompt('Enter a new Caption for the Column');
+                        if (newname) {
+                            this.api.layoutApi.setColumnCaption(column.columnId, newname);
+                        }
+                    }));
+                }
+                if (column.hideable) {
+                    returnColumnMenuItems.push(this.createColumnMenuItemClickFunction('Hide Column', 'hide-column', () => {
+                        this.api.columnApi.hideColumn(column.columnId);
+                    }));
+                }
+            }
             let selectMenuItems = [];
             if (column) {
                 selectMenuItems.push(this.createColumnMenuItemClickFunction('Column', 'column-chooser', () => {
@@ -67,7 +80,7 @@ class LayoutModule extends AdaptableModuleBase_1.AdaptableModuleBase {
     }
     addContextMenuItems(menuContext) {
         let returnColumnMenuItems = [];
-        if (this.isModuleEditable()) {
+        if (this.isModuleEditable() && !this.api.layoutApi.isCurrentLayoutReadOnly()) {
             returnColumnMenuItems.push(this.createColumnMenuItemShowPopup('Edit Layout', this.moduleInfo.Popup, this.moduleInfo.Glyph, {
                 action: 'Edit',
                 source: 'ColumnMenu',

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,31 @@ 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() {
+                return 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,10 @@
+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;
+}