@adaptabletools/adaptable 22.1.1 → 23.0.0-canary.0

package/src/Redux/ActionsReducers/ExportRedux.js

@@ -1,5 +1,7 @@
 import { EMPTY_ARRAY } from '../../Utilities/Constants/GeneralConstants';
 import AdaptableHelper from '../../Utilities/Helpers/AdaptableHelper';
+import { ensureExportStateSchedulesUuids, normalizeScheduledReportSchedule, replaceScheduledReportScheduleInList, } from '../../Utilities/Helpers/ScheduledReportHelper';
+import { changeIsSuspendInList } from './utils';
 /**
  * @ReduxAction A Report has been selected
  */
@@ -20,10 +22,35 @@ export const REPORT_DELETE = 'REPORT_DELETE';
  * @ReduxAction Export Module is ready
  */
 export const EXPORT_READY = 'EXPORT_READY';
+export const EXPORT_ENSURE_SCHEDULE_UUIDS = 'EXPORT_ENSURE_SCHEDULE_UUIDS';
 /**
  * @ReduxAction A report Format has been selected
  */
 export const FORMAT_SELECT = 'FORMAT_SELECT';
+/**
+ * @ReduxAction A Scheduled Report has been added
+ */
+export const SCHEDULED_REPORT_ADD = 'SCHEDULED_REPORT_ADD';
+/**
+ * @ReduxAction A Scheduled Report has been edited
+ */
+export const SCHEDULED_REPORT_EDIT = 'SCHEDULED_REPORT_EDIT';
+/**
+ * @ReduxAction A Scheduled Report has been deleted
+ */
+export const SCHEDULED_REPORT_DELETE = 'SCHEDULED_REPORT_DELETE';
+/**
+ * @ReduxAction A Scheduled Report has been suspended
+ */
+export const SCHEDULED_REPORT_SUSPEND = 'SCHEDULED_REPORT_SUSPEND';
+/**
+ * @ReduxAction A Scheduled Report has been unsuspended
+ */
+export const SCHEDULED_REPORT_UNSUSPEND = 'SCHEDULED_REPORT_UNSUSPEND';
+/**
+ * @ReduxAction A Scheduled Report job has been run
+ */
+export const SCHEDULED_REPORT_JOB_RUN = 'SCHEDULED_REPORT_JOB_RUN';
 export const ReportSelect = (SelectedReport) => ({
     type: REPORT_SELECT,
     SelectedReport,
@@ -44,12 +71,46 @@ export const ExportReady = (exportState) => ({
     type: EXPORT_READY,
     exportState,
 });
+export const ExportEnsureScheduleUuids = () => ({
+    type: EXPORT_ENSURE_SCHEDULE_UUIDS,
+});
 export const FormatSelect = (SelectedFormat) => ({
     type: FORMAT_SELECT,
     SelectedFormat,
 });
+export const ScheduledReportAdd = (reportSchedule) => ({
+    type: SCHEDULED_REPORT_ADD,
+    reportSchedule,
+});
+export const ScheduledReportEdit = (reportSchedule) => ({
+    type: SCHEDULED_REPORT_EDIT,
+    reportSchedule,
+});
+export const ScheduledReportDelete = (reportSchedule) => ({
+    type: SCHEDULED_REPORT_DELETE,
+    reportSchedule,
+});
+export const ScheduledReportSuspend = (reportSchedule) => ({
+    type: SCHEDULED_REPORT_SUSPEND,
+    reportSchedule,
+});
+export const ScheduledReportUnSuspend = (reportSchedule) => ({
+    type: SCHEDULED_REPORT_UNSUSPEND,
+    reportSchedule,
+});
+export const ScheduledReportJobRun = (reportSchedule) => ({
+    type: SCHEDULED_REPORT_JOB_RUN,
+    reportSchedule,
+});
+function updateScheduledReports(state, updater) {
+    return {
+        ...state,
+        ReportSchedules: updater(state.ReportSchedules ?? []),
+    };
+}
 const initialState = {
     Reports: EMPTY_ARRAY,
+    ReportSchedules: EMPTY_ARRAY,
 };
 export const ExportReducer = (state = initialState, action) => {
     let reports;
@@ -72,16 +133,52 @@ export const ExportReducer = (state = initialState, action) => {
                 Reports: state.Reports.map((abObject) => abObject.Uuid === actionReport.Uuid ? actionReport : abObject),
             };
         case REPORT_DELETE: {
-            const actionReport = action.report;
+            const deletedReport = action.report;
             return {
                 ...state,
-                Reports: state.Reports.filter((abObject) => abObject.Uuid !== actionReport.Uuid),
+                Reports: state.Reports.filter((abObject) => abObject.Uuid !== deletedReport.Uuid),
+                ReportSchedules: (state.ReportSchedules ?? []).filter((schedule) => schedule.ReportName !== deletedReport.Name),
             };
         }
         case FORMAT_SELECT:
             return Object.assign({}, state, {
                 CurrentFormat: action.SelectedFormat,
             });
+        case EXPORT_READY:
+            return ensureExportStateSchedulesUuids(action.exportState ?? state);
+        case EXPORT_ENSURE_SCHEDULE_UUIDS:
+            return ensureExportStateSchedulesUuids(state);
+        case SCHEDULED_REPORT_ADD: {
+            const { reportSchedule } = action;
+            const ensuredState = ensureExportStateSchedulesUuids(state);
+            const normalized = normalizeScheduledReportSchedule(reportSchedule);
+            AdaptableHelper.addAdaptableObjectPrimitives(normalized);
+            return updateScheduledReports(ensuredState, (schedules) => [...schedules, normalized]);
+        }
+        case SCHEDULED_REPORT_EDIT: {
+            const { reportSchedule } = action;
+            const ensuredState = ensureExportStateSchedulesUuids(state);
+            const normalized = normalizeScheduledReportSchedule(reportSchedule);
+            AdaptableHelper.addAdaptableObjectPrimitives(normalized);
+            return updateScheduledReports(ensuredState, (schedules) => replaceScheduledReportScheduleInList(schedules, normalized));
+        }
+        case SCHEDULED_REPORT_DELETE: {
+            const { reportSchedule } = action;
+            const ensuredState = ensureExportStateSchedulesUuids(state);
+            return updateScheduledReports(ensuredState, (schedules) => schedules.filter((s) => s.Uuid !== reportSchedule.Uuid));
+        }
+        case SCHEDULED_REPORT_SUSPEND: {
+            const { reportSchedule } = action;
+            const ensuredState = ensureExportStateSchedulesUuids(state);
+            return updateScheduledReports(ensuredState, (schedules) => changeIsSuspendInList(reportSchedule, schedules, true));
+        }
+        case SCHEDULED_REPORT_UNSUSPEND: {
+            const { reportSchedule } = action;
+            const ensuredState = ensureExportStateSchedulesUuids(state);
+            return updateScheduledReports(ensuredState, (schedules) => changeIsSuspendInList(reportSchedule, schedules, false));
+        }
+        case SCHEDULED_REPORT_JOB_RUN:
+            return state;
         default:
             return state;
     }

package/src/Redux/ActionsReducers/InternalRedux.d.ts

@@ -38,7 +38,6 @@ export declare const ALERT_DELETE_ALL = "ALERT_DELETE_ALL";
 export declare const ALERT_REMOVE_CELL_HIGHLIGHT = "ALERT_REMOVE_CELL_HIGHLIGHT";
 export declare const ALERT_REMOVE_ROW_HIGHLIGHT = "ALERT_REMOVE_ROW_HIGHLIGHT";
 export declare const SYSTEM_STATUS_MESSAGE_INFO_ADD = "SYSTEM_STATUS_MESSAGE_INFO_ADD";
-export declare const SYSTEM_STATUS_MESSAGE_INFO_DELETE = "SYSTEM_STATUS_MESSAGE_INFO_DELETE";
 export declare const SYSTEM_STATUS_MESSAGE_INFO_DELETE_ALL = "SYSTEM_STATUS_MESSAGE_INFO_DELETE_ALL";
 export declare const SMARTEDIT_CHECK_CELL_SELECTION = "SMARTEDIT_CHECK_CELL_SELECTION";
 export declare const SMARTEDIT_FETCH_PREVIEW = "SMARTEDIT_FETCH_PREVIEW";
@@ -179,9 +178,6 @@ export interface SystemStatusMessageInfoAddAction extends Redux.Action {
     systemStatusMessageInfo: SystemStatusMessageInfo;
     maxSystemStatusMessagesInStore: number;
 }
-export interface SystemStatusMessageInfoDeleteAction extends Redux.Action {
-    systemStatusMessageInfo: SystemStatusMessageInfo;
-}
 export interface SystemStatusMessageInfoDeleteAllAction extends Redux.Action {
 }
 export interface SetAvailableFilterValuesAction extends Redux.Action {
@@ -314,7 +310,6 @@ export declare const AdaptableAlertRemoveRowHighlight: (alert: AdaptableAlert) =
 export declare const CreateCellSummaryInfo: () => CreateCellSummaryInfoAction;
 export declare const SetCellSummaryInfo: (CellSummary: CellSummmaryInfo) => SetCellSummaryInfoAction;
 export declare const SystemStatusMessageInfoAdd: (SystemStatusMessageInfo: SystemStatusMessageInfo, MaxSystemStatusMessagesInStore: number) => SystemStatusMessageInfoAddAction;
-export declare const SystemStatusMessageInfoDelete: (SystemStatusMessageInfo: SystemStatusMessageInfo) => SystemStatusMessageInfoDeleteAction;
 export declare const SystemStatusMessageInfoDeleteAll: () => SystemStatusMessageInfoDeleteAllAction;
 export declare const SmartEditChangeValue: (value: number) => SmartEditChangeValueAction;
 export declare const SmartEditChangeOperation: (smartEditOperation: SmartEditOperation) => SmartEditChangeOperationAction;

package/src/Redux/ActionsReducers/InternalRedux.js

@@ -2,6 +2,7 @@ import { EMPTY_ARRAY, EMPTY_STRING } from '../../Utilities/Constants/GeneralCons
 import { CELL_SUMMARY_DEFAULT_OPERATION } from '../../Utilities/Constants/ReduxConstants';
 import { MathOperation } from '../../AdaptableState/Common/Enums';
 import { cloneObject } from '../../Utilities/Helpers/Helper';
+import { getRuleAlertProperties } from '../../Utilities/Helpers/ScheduledAlertHelper';
 import { AnnotationsService } from '../../Utilities/Services/AnnotationsService';
 /*
 Bit of a mixed bag of actions but essentially its those that are related to Strategies but where we DONT want to persist state
@@ -40,7 +41,6 @@ export const ALERT_REMOVE_CELL_HIGHLIGHT = 'ALERT_REMOVE_CELL_HIGHLIGHT';
 export const ALERT_REMOVE_ROW_HIGHLIGHT = 'ALERT_REMOVE_ROW_HIGHLIGHT';
 // Status Message
 export const SYSTEM_STATUS_MESSAGE_INFO_ADD = 'SYSTEM_STATUS_MESSAGE_INFO_ADD';
-export const SYSTEM_STATUS_MESSAGE_INFO_DELETE = 'SYSTEM_STATUS_MESSAGE_INFO_DELETE';
 export const SYSTEM_STATUS_MESSAGE_INFO_DELETE_ALL = 'SYSTEM_STATUS_MESSAGE_INFO_DELETE_ALL';
 // Smart Edit
 export const SMARTEDIT_CHECK_CELL_SELECTION = 'SMARTEDIT_CHECK_CELL_SELECTION';
@@ -196,10 +196,6 @@ export const SystemStatusMessageInfoAdd = (SystemStatusMessageInfo, MaxSystemSta
     systemStatusMessageInfo: SystemStatusMessageInfo,
     maxSystemStatusMessagesInStore: MaxSystemStatusMessagesInStore,
 });
-export const SystemStatusMessageInfoDelete = (SystemStatusMessageInfo) => ({
-    type: SYSTEM_STATUS_MESSAGE_INFO_DELETE,
-    systemStatusMessageInfo: SystemStatusMessageInfo,
-});
 export const SystemStatusMessageInfoDeleteAll = () => ({
     type: SYSTEM_STATUS_MESSAGE_INFO_DELETE_ALL,
 });
@@ -557,7 +553,10 @@ export const InternalReducer = (state = initialState, action) => {
                             ...abObject,
                         };
                         newAbObject.alertDefinition = cloneObject(abObject.alertDefinition);
-                        delete newAbObject.alertDefinition.AlertProperties.HighlightCell;
+                        const ruleAlertProperties = getRuleAlertProperties(newAbObject.alertDefinition);
+                        if (ruleAlertProperties) {
+                            delete ruleAlertProperties.HighlightCell;
+                        }
                         return newAbObject;
                     }
                     return abObject;
@@ -576,7 +575,10 @@ export const InternalReducer = (state = initialState, action) => {
                             ...abObject,
                         };
                         newAbObject.alertDefinition = cloneObject(abObject.alertDefinition);
-                        delete newAbObject.alertDefinition.AlertProperties.HighlightRow;
+                        const ruleAlertProperties = getRuleAlertProperties(newAbObject.alertDefinition);
+                        if (ruleAlertProperties) {
+                            delete ruleAlertProperties.HighlightRow;
+                        }
                         return newAbObject;
                     }
                     return abObject;

package/src/Redux/ActionsReducers/QuickSearchRedux.d.ts

@@ -1,18 +1,35 @@
 import * as Redux from 'redux';
 import { QuickSearchState } from '../../AdaptableState/QuickSearchState';
 import { AdaptableStyle } from '../../AdaptableState/Common/AdaptableStyle';
-export declare const QUICK_SEARCH_SET_CELL_MATCHING_STYLE_DEFAULT: {
+export declare const QUICK_SEARCH_DEFAULT_CELL_MATCH_STYLE: {
     BackColor: string;
     ForeColor: string;
 };
+export declare const QUICK_SEARCH_DEFAULT_TEXT_MATCH_STYLE: {
+    BackColor: string;
+    ForeColor: string;
+};
+export declare const QUICK_SEARCH_DEFAULT_CURRENT_TEXT_MATCH_STYLE: {
+    BackColor: string;
+    ForeColor: string;
+    FontWeight: "Bold";
+};
 /**
  * @ReduxAction Runs Quick Search
  */
 export declare const QUICK_SEARCH_RUN = "QUICK_SEARCH_RUN";
 /**
- * @ReduxAction Sets Quick Search style
+ * @ReduxAction Sets Quick Search whole-cell style (SSRM / legacy)
  */
 export declare const QUICK_SEARCH_SET_CELL_MATCHING_STYLE = "QUICK_SEARCH_SET_CELL_MATCHING_STYLE";
+/**
+ * @ReduxAction Sets Quick Search matched-text style (AG Grid Find)
+ */
+export declare const QUICK_SEARCH_SET_TEXT_MATCHING_STYLE = "QUICK_SEARCH_SET_TEXT_MATCHING_STYLE";
+/**
+ * @ReduxAction Sets Quick Search active-match text style (AG Grid Find)
+ */
+export declare const QUICK_SEARCH_SET_CURRENT_TEXT_MATCHING_STYLE = "QUICK_SEARCH_SET_CURRENT_TEXT_MATCHING_STYLE";
 /**
  * @ReduxAction Quick Search Module is ready
  */
@@ -23,10 +40,18 @@ export interface QuickSearchRunAction extends Redux.Action {
 export interface QuickSearchSetMatchingCellStyleAction extends Redux.Action {
     matchingCellStyle: AdaptableStyle;
 }
+export interface QuickSearchSetTextMatchingStyleAction extends Redux.Action {
+    textMatchStyle: AdaptableStyle;
+}
+export interface QuickSearchSetCurrentTextMatchingStyleAction extends Redux.Action {
+    currentTextMatchStyle: AdaptableStyle;
+}
 export interface QuickSearchReadyAction extends Redux.Action {
     quickSearchState: QuickSearchState;
 }
 export declare const QuickSearchRun: (quickSearchText: string) => QuickSearchRunAction;
 export declare const QuickSearchSetCellMatchingStyle: (matchingCellStyle: AdaptableStyle) => QuickSearchSetMatchingCellStyleAction;
+export declare const QuickSearchSetTextMatchingStyle: (textMatchStyle: AdaptableStyle) => QuickSearchSetTextMatchingStyleAction;
+export declare const QuickSearchSetCurrentTextMatchingStyle: (currentTextMatchStyle: AdaptableStyle) => QuickSearchSetCurrentTextMatchingStyleAction;
 export declare const QuickSearchReady: (quickSearchState: QuickSearchState) => QuickSearchReadyAction;
 export declare const QuickSearchReducer: Redux.Reducer<QuickSearchState>;

package/src/Redux/ActionsReducers/QuickSearchRedux.js

@@ -1,17 +1,34 @@
-import { QUICK_SEARCH_DEFAULT_BACK_COLOR, QUICK_SEARCH_DEFAULT_FORE_COLOR, } from '../../Utilities/Constants/ReduxConstants';
+import { QUICK_SEARCH_DEFAULT_CELL_BACK_COLOR, QUICK_SEARCH_DEFAULT_CURRENT_BACK_COLOR, QUICK_SEARCH_DEFAULT_FORE_COLOR, QUICK_SEARCH_DEFAULT_TEXT_BACK_COLOR, } from '../../Utilities/Constants/ReduxConstants';
 import { EMPTY_STRING } from '../../Utilities/Constants/GeneralConstants';
-export const QUICK_SEARCH_SET_CELL_MATCHING_STYLE_DEFAULT = {
-    BackColor: QUICK_SEARCH_DEFAULT_BACK_COLOR,
+export const QUICK_SEARCH_DEFAULT_CELL_MATCH_STYLE = {
+    BackColor: QUICK_SEARCH_DEFAULT_CELL_BACK_COLOR,
     ForeColor: QUICK_SEARCH_DEFAULT_FORE_COLOR,
 };
+export const QUICK_SEARCH_DEFAULT_TEXT_MATCH_STYLE = {
+    BackColor: QUICK_SEARCH_DEFAULT_TEXT_BACK_COLOR,
+    ForeColor: QUICK_SEARCH_DEFAULT_FORE_COLOR,
+};
+export const QUICK_SEARCH_DEFAULT_CURRENT_TEXT_MATCH_STYLE = {
+    BackColor: QUICK_SEARCH_DEFAULT_CURRENT_BACK_COLOR,
+    ForeColor: QUICK_SEARCH_DEFAULT_FORE_COLOR,
+    FontWeight: 'Bold',
+};
 /**
  * @ReduxAction Runs Quick Search
  */
 export const QUICK_SEARCH_RUN = 'QUICK_SEARCH_RUN';
 /**
- * @ReduxAction Sets Quick Search style
+ * @ReduxAction Sets Quick Search whole-cell style (SSRM / legacy)
  */
 export const QUICK_SEARCH_SET_CELL_MATCHING_STYLE = 'QUICK_SEARCH_SET_CELL_MATCHING_STYLE';
+/**
+ * @ReduxAction Sets Quick Search matched-text style (AG Grid Find)
+ */
+export const QUICK_SEARCH_SET_TEXT_MATCHING_STYLE = 'QUICK_SEARCH_SET_TEXT_MATCHING_STYLE';
+/**
+ * @ReduxAction Sets Quick Search active-match text style (AG Grid Find)
+ */
+export const QUICK_SEARCH_SET_CURRENT_TEXT_MATCHING_STYLE = 'QUICK_SEARCH_SET_CURRENT_TEXT_MATCHING_STYLE';
 /**
  * @ReduxAction Quick Search Module is ready
  */
@@ -24,6 +41,14 @@ export const QuickSearchSetCellMatchingStyle = (matchingCellStyle) => ({
     type: QUICK_SEARCH_SET_CELL_MATCHING_STYLE,
     matchingCellStyle: matchingCellStyle,
 });
+export const QuickSearchSetTextMatchingStyle = (textMatchStyle) => ({
+    type: QUICK_SEARCH_SET_TEXT_MATCHING_STYLE,
+    textMatchStyle,
+});
+export const QuickSearchSetCurrentTextMatchingStyle = (currentTextMatchStyle) => ({
+    type: QUICK_SEARCH_SET_CURRENT_TEXT_MATCHING_STYLE,
+    currentTextMatchStyle,
+});
 export const QuickSearchReady = (quickSearchState) => ({
     type: QUICK_SEARCH_READY,
     quickSearchState,
@@ -41,6 +66,15 @@ export const QuickSearchReducer = (state = initialState, action) => {
             return Object.assign({}, state, {
                 CellMatchStyle: action.matchingCellStyle,
             });
+        case QUICK_SEARCH_SET_TEXT_MATCHING_STYLE:
+            return Object.assign({}, state, {
+                TextMatchStyle: action.textMatchStyle,
+            });
+        case QUICK_SEARCH_SET_CURRENT_TEXT_MATCHING_STYLE:
+            return Object.assign({}, state, {
+                CurrentTextMatchStyle: action
+                    .currentTextMatchStyle,
+            });
         default:
             return state;
     }

package/src/Redux/Store/AdaptableStore.js

@@ -5,6 +5,9 @@ import { PROGRESS_INDICATOR_HIDE, PROGRESS_INDICATOR_SHOW } from '../ActionsRedu
 import { createEngine as createEngineLocal } from './AdaptableReduxLocalStorageEngine';
 import { mergeReducer } from './AdaptableReduxMerger';
 import { isAdaptableCellChangedAlert, isAdaptableRowChangedAlert, } from '../../AdaptableState/Common/AdaptableAlert';
+import { closeAgChartDefinitionIfOpen, closeExternalChartDefinitionIfOpen, } from '../../Utilities/Helpers/chartingHelper';
+import { refreshScheduledAlertJobs, refreshScheduledReportJobs, } from '../../Utilities/Helpers/ScheduledJobsMiddlewareHelper';
+import { getRuleAlertProperties, isScheduledAlertDefinition, } from '../../Utilities/Helpers/ScheduledAlertHelper';
 import { ERROR_LAYOUT } from '../../Utilities/Constants/GeneralConstants';
 import * as ModuleConstants from '../../Utilities/Constants/ModuleConstants';
 import Emitter from '../../Utilities/Emitter';
@@ -29,7 +32,6 @@ import * as NamedQueryRedux from '../ActionsReducers/NamedQueryRedux';
 import * as NoteRedux from '../ActionsReducers/NoteRedux';
 import * as PlusMinusRedux from '../ActionsReducers/PlusMinusRedux';
 import * as QuickSearchRedux from '../ActionsReducers/QuickSearchRedux';
-import * as ScheduleRedux from '../ActionsReducers/ScheduleRedux';
 import * as ShortcutRedux from '../ActionsReducers/ShortcutRedux';
 import * as SmartEditRedux from '../ActionsReducers/SmartEditRedux';
 import * as StatusBarRedux from '../ActionsReducers/StatusBarRedux';
@@ -125,7 +127,6 @@ export class AdaptableStore {
             Note: NoteRedux.NoteReducer,
             PlusMinus: PlusMinusRedux.PlusMinusReducer,
             QuickSearch: QuickSearchRedux.QuickSearchReducer,
-            Schedule: ScheduleRedux.ScheduleReducer,
             Shortcut: ShortcutRedux.ShortcutReducer,
             StatusBar: StatusBarRedux.StatusBarReducer,
             StyledColumn: StyledColumnRedux.StyledColumnReducer,
@@ -484,17 +485,20 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                 case AlertRedux.ALERT_DEFINITION_UNSUSPEND_ALL:
                 case AlertRedux.ALERT_DEFINITION_SUSPEND_ALL: {
                     const returnAction = next(action);
-                    const alertDefinition = returnAction
-                        .alertDefinition;
-                    if (returnAction.type === AlertRedux.ALERT_DEFINITION_ADD ||
-                        returnAction.type === AlertRedux.ALERT_DEFINITION_EDIT ||
-                        returnAction.type === AlertRedux.ALERT_DEFINITION_UNSUSPEND) {
-                        // in case of edit, the existing reactive alert will be deleted and recreated
-                        adaptable.api.internalApi.getAlertService().createReactiveAlert(alertDefinition);
-                    }
-                    if (returnAction.type === AlertRedux.ALERT_DEFINITION_DELETE ||
-                        returnAction.type === AlertRedux.ALERT_DEFINITION_SUSPEND) {
-                        adaptable.api.internalApi.getAlertService().deleteReactiveAlert(alertDefinition);
+                    const alertDefinition = returnAction.alertDefinition;
+                    if (alertDefinition) {
+                        if (!isScheduledAlertDefinition(alertDefinition) &&
+                            (returnAction.type === AlertRedux.ALERT_DEFINITION_ADD ||
+                                returnAction.type === AlertRedux.ALERT_DEFINITION_EDIT ||
+                                returnAction.type === AlertRedux.ALERT_DEFINITION_UNSUSPEND)) {
+                            // in case of edit, the existing reactive alert will be deleted and recreated
+                            adaptable.api.internalApi.getAlertService().createReactiveAlert(alertDefinition);
+                        }
+                        if (!isScheduledAlertDefinition(alertDefinition) &&
+                            (returnAction.type === AlertRedux.ALERT_DEFINITION_DELETE ||
+                                returnAction.type === AlertRedux.ALERT_DEFINITION_SUSPEND)) {
+                            adaptable.api.internalApi.getAlertService().deleteReactiveAlert(alertDefinition);
+                        }
                     }
                     if (returnAction.type === AlertRedux.ALERT_DEFINITION_SUSPEND_ALL) {
                         adaptable.api.internalApi
@@ -524,6 +528,7 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     if (module) {
                         module.checkListenToCellDataChanged();
                     }
+                    refreshScheduledAlertJobs(adaptable);
                     return returnAction;
                 }
                 /*******************
@@ -620,6 +625,16 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                  * Action: We set up all columns again
                  */
                 case QuickSearchRedux.QUICK_SEARCH_SET_CELL_MATCHING_STYLE:
+                case QuickSearchRedux.QUICK_SEARCH_SET_TEXT_MATCHING_STYLE:
+                case QuickSearchRedux.QUICK_SEARCH_SET_CURRENT_TEXT_MATCHING_STYLE: {
+                    const returnAction = next(action);
+                    adaptable.applyQuickSearchFindCssVars();
+                    if (StringExtensions.IsNotNullOrEmpty(adaptable.api.quickSearchApi.getQuickSearchValue())) {
+                        adaptable.refreshAgGridFind();
+                    }
+                    adaptable.updateColumnModelAndRefreshGrid();
+                    return returnAction;
+                }
                 case FormatColumnRedux.FORMAT_COLUMN_ADD_BATCH:
                 case FormatColumnRedux.FORMAT_COLUMN_ADD:
                 case FormatColumnRedux.FORMAT_COLUMN_EDIT:
@@ -660,10 +675,10 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                  */
                 case QuickSearchRedux.QUICK_SEARCH_RUN: {
                     let returnAction = next(action);
-                    adaptable.api.gridApi.refreshAllCells(true);
                     const actionTyped = action;
                     const searchText = actionTyped.quickSearchText;
                     adaptable.setAgGridFindSearchValue(searchText);
+                    adaptable.api.gridApi.refreshAllCells(true);
                     // if set then return a query on the text
                     if (adaptable.adaptableOptions.quickSearchOptions.filterGridAfterQuickSearch) {
                         if (StringExtensions.IsNotNullOrEmpty(searchText)) {
@@ -686,13 +701,13 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     const actionTyped = action;
                     let ret = next(action);
                     const adaptableAlert = actionTyped.alert;
-                    if (adaptableAlert.alertDefinition.AlertProperties?.HighlightCell &&
+                    if (getRuleAlertProperties(adaptableAlert.alertDefinition)?.HighlightCell &&
                         isAdaptableCellChangedAlert(adaptableAlert) &&
                         adaptableAlert.cellDataChangedInfo) {
                         const rowNode = adaptableAlert.cellDataChangedInfo.rowNode;
                         adaptable.api.gridApi.refreshCell(rowNode, adaptableAlert.cellDataChangedInfo.column.columnId, true);
                     }
-                    if (adaptableAlert.alertDefinition.AlertProperties?.HighlightRow &&
+                    if (getRuleAlertProperties(adaptableAlert.alertDefinition)?.HighlightRow &&
                         isAdaptableRowChangedAlert(adaptableAlert) &&
                         adaptableAlert.rowDataChangedInfo) {
                         adaptable.api.gridApi.refreshRowNodes(adaptableAlert.rowDataChangedInfo.rowNodes);
@@ -708,13 +723,13 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     let ret = next(action);
                     let alerts = actionTyped.alerts;
                     alerts.forEach((alert) => {
-                        if (alert.alertDefinition.AlertProperties?.HighlightCell &&
+                        if (getRuleAlertProperties(alert.alertDefinition)?.HighlightCell &&
                             isAdaptableCellChangedAlert(alert) &&
                             alert.cellDataChangedInfo) {
                             let rowNode = alert.cellDataChangedInfo.rowNode;
                             adaptable.api.gridApi.refreshCell(rowNode, alert.cellDataChangedInfo.column.columnId, true);
                         }
-                        if (alert.alertDefinition.AlertProperties?.HighlightRow &&
+                        if (getRuleAlertProperties(alert.alertDefinition)?.HighlightRow &&
                             isAdaptableRowChangedAlert(alert) &&
                             alert.rowDataChangedInfo) {
                             adaptable.api.gridApi.refreshRowNodes(alert.rowDataChangedInfo.rowNodes);
@@ -730,7 +745,7 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     let ret = next(action);
                     const actionTyped = action;
                     const adaptableAlert = actionTyped.alert;
-                    if (adaptableAlert.alertDefinition.AlertProperties?.HighlightCell) {
+                    if (getRuleAlertProperties(adaptableAlert.alertDefinition)?.HighlightCell) {
                         if (isAdaptableCellChangedAlert(adaptableAlert) &&
                             adaptableAlert.cellDataChangedInfo) {
                             const rowNode = adaptableAlert.cellDataChangedInfo.rowNode;
@@ -743,7 +758,7 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     let ret = next(action);
                     const actionTyped = action;
                     const adaptableAlert = actionTyped.alert;
-                    if (adaptableAlert.alertDefinition.AlertProperties?.HighlightRow) {
+                    if (getRuleAlertProperties(adaptableAlert.alertDefinition)?.HighlightRow) {
                         if (isAdaptableCellChangedAlert(adaptableAlert) &&
                             adaptableAlert.cellDataChangedInfo) {
                             adaptable.api.gridApi.refreshRowNodes([adaptableAlert.cellDataChangedInfo.rowNode]);
@@ -992,43 +1007,16 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     return returnAction;
                 }
                 /*******************
-                 * SCHEDULE ACTIONS
+                 * SCHEDULED JOB ACTIONS (export report schedules)
                  *******************/
-                /**
-                 * Use Case: Schedule has changed
-                 * Action: Set up ALL jobs
-                 */
-                case ScheduleRedux.REMINDER_SCHEDULE_ADD:
-                case ScheduleRedux.REMINDER_SCHEDULE_EDIT:
-                case ScheduleRedux.REMINDER_SCHEDULE_DELETE:
-                case ScheduleRedux.REMINDER_SCHEDULE_UNSUSPEND:
-                case ScheduleRedux.REMINDER_SCHEDULE_SUSPEND:
-                case ScheduleRedux.REMINDER_SCHEDULE_UNSUSPEND_ALL:
-                case ScheduleRedux.REMINDER_SCHEDULE_SUSPEND_ALL:
-                case ScheduleRedux.REPORT_SCHEDULE_ADD:
-                case ScheduleRedux.REPORT_SCHEDULE_EDIT:
-                case ScheduleRedux.REPORT_SCHEDULE_DELETE:
-                case ScheduleRedux.REPORT_SCHEDULE_SUSPEND:
-                case ScheduleRedux.REPORT_SCHEDULE_UNSUSPEND:
-                case ScheduleRedux.REPORT_SCHEDULE_SUSPEND_ALL:
-                case ScheduleRedux.REPORT_SCHEDULE_UNSUSPEND_ALL:
-                case ScheduleRedux.IPUSHPULL_SCHEDULE_ADD:
-                case ScheduleRedux.IPUSHPULL_SCHEDULE_EDIT:
-                case ScheduleRedux.IPUSHPULL_SCHEDULE_DELETE:
-                case ScheduleRedux.IPUSHPULL_SCHEDULE_SUSPEND:
-                case ScheduleRedux.IPUSHPULL_SCHEDULE_UNSUSPEND:
-                case ScheduleRedux.IPUSHPULL_SCHEDULE_SUSPEND_ALL:
-                case ScheduleRedux.IPUSHPULL_SCHEDULE_UNSUSPEND_ALL:
-                case ScheduleRedux.OPENFIN_SCHEDULE_ADD:
-                case ScheduleRedux.OPENFIN_SCHEDULE_EDIT:
-                case ScheduleRedux.OPENFIN_SCHEDULE_DELETE:
-                case ScheduleRedux.OPENFIN_SCHEDULE_SUSPEND:
-                case ScheduleRedux.OPENFIN_SCHEDULE_UNSUSPEND:
-                case ScheduleRedux.OPENFIN_SCHEDULE_SUSPEND_ALL:
-                case ScheduleRedux.OPENFIN_SCHEDULE_UNSUSPEND_ALL: {
-                    let returnAction = next(action);
-                    let module = (adaptable.adaptableModules.get(ModuleConstants.ScheduleModuleId));
-                    module.setUpScheduleJobs();
+                case ExportRedux.EXPORT_ENSURE_SCHEDULE_UUIDS:
+                case ExportRedux.SCHEDULED_REPORT_ADD:
+                case ExportRedux.SCHEDULED_REPORT_EDIT:
+                case ExportRedux.SCHEDULED_REPORT_DELETE:
+                case ExportRedux.SCHEDULED_REPORT_SUSPEND:
+                case ExportRedux.SCHEDULED_REPORT_UNSUSPEND: {
+                    const returnAction = next(action);
+                    refreshScheduledReportJobs(adaptable);
                     return returnAction;
                 }
                 /*******************
@@ -1063,7 +1051,6 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                 case DashboardRedux.DASHBOARD_SET_MODULE_BUTTONS:
                 case DashboardRedux.DASHBOARD_ACTIVE_TAB_INDEX_CHANGE:
                 case DashboardRedux.DASHBOARD_SET_IS_FLOATING:
-                case DashboardRedux.DASHBOARD_SET_IS_INLINE:
                 case DashboardRedux.DASHBOARD_SET_IS_HIDDEN:
                 case DashboardRedux.DASHBOARD_SET_FLOATING_POSITION:
                 case DashboardRedux.DASHBOARD_SET_TABS:
@@ -1297,7 +1284,11 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                  */
                 case PlusMinusRedux.PLUS_MINUS_RULE_ADD:
                 case PlusMinusRedux.PLUS_MINUS_RULE_EDIT:
-                case PlusMinusRedux.PLUS_MINUS_RULE_DELETE: {
+                case PlusMinusRedux.PLUS_MINUS_RULE_DELETE:
+                case PlusMinusRedux.PLUS_MINUS_RULE_SUSPEND:
+                case PlusMinusRedux.PLUS_MINUS_RULE_UNSUSPEND:
+                case PlusMinusRedux.PLUS_MINUS_RULE_SUSPEND_ALL:
+                case PlusMinusRedux.PLUS_MINUS_RULE_UNSUSPEND_ALL: {
                     let returnAction = next(action);
                     let module = (adaptable.adaptableModules.get(ModuleConstants.PlusMinusModuleId));
                     if (module) {
@@ -1350,16 +1341,24 @@ const adaptableMiddleware = (adaptable) => (function(middlewareAPI) {
                     const actionTyped = action;
                     let report = actionTyped.report;
                     let currentReport = middlewareAPI.getState().Export.CurrentReport;
+                    const returnAction = next(action);
                     if (report && report.Name == currentReport) {
                         adaptable.api.exportApi.clearReport();
                     }
-                    return next(action);
+                    refreshScheduledReportJobs(adaptable);
+                    return returnAction;
                 }
                 /*******************
                  * CHARTING ACTIONS
                  *******************/
+                case ChartingRedux.CHARTING_DELETE_CHART: {
+                    const deleteAction = action;
+                    closeAgChartDefinitionIfOpen(adaptable.api, deleteAction.chartDefinition);
+                    return next(action);
+                }
                 case ChartingRedux.CHARTING_DELETE_EXTERNAL_CHART: {
                     const returnAction = next(action);
+                    closeExternalChartDefinitionIfOpen(adaptable.api, returnAction.chartDefinition);
                     adaptable.api.chartingApi.internalApi.onDeleteExternalChart(returnAction.chartDefinition);
                     return returnAction;
                 }

package/src/Strategy/AlertModule.d.ts

@@ -9,10 +9,13 @@ import { LayoutExtendedConfig } from '../types';
 import { AdaptableModuleBase } from './AdaptableModuleBase';
 import { ICellDataChangeListenerModule } from './Interface/ICellDataChangeListenerModule';
 import { AdaptableModuleView, AdaptableObjectCompactView, AdaptableObjectView } from './Interface/IModule';
-export declare class AlertModule extends AdaptableModuleBase implements ICellDataChangeListenerModule {
+import { IAlertModule } from './Interface/IAlertModule';
+export declare class AlertModule extends AdaptableModuleBase implements ICellDataChangeListenerModule, IAlertModule {
     private isListeningToCellDataChanges;
+    private scheduledAlertJobManager;
     constructor(api: AdaptableApi);
     onAdaptableReady(): void;
+    setUpScheduledAlertJobs(): void;
     shouldListenToDataChanges(): boolean;
     checkListenToCellDataChanged(): void;
     setupCellDataChangeListener(): void;