@gooddata/sdk-ui-dashboard 11.39.0-alpha.3 → 11.39.0

package/esm/model/react/useDashboardCommandProcessing.d.ts

@@ -159,8 +159,12 @@ export declare const useDashboardCommandProcessing: <TCommand extends DashboardC
         type: TSuccessEventType;
     }> | Extract<import("../events/filters.js").IDashboardMeasureValueFilterAdded, {
         type: TSuccessEventType;
+    }> | Extract<import("../events/filters.js").IDashboardMeasureValueFilterConditionChanged, {
+        type: TSuccessEventType;
     }> | Extract<import("../events/filters.js").IDashboardMeasureValueFilterConfigModeChanged, {
         type: TSuccessEventType;
+    }> | Extract<import("../events/filters.js").IDashboardMeasureValueFilterDimensionalityChanged, {
+        type: TSuccessEventType;
     }> | Extract<import("../events/filters.js").IDashboardMeasureValueFilterMoved, {
         type: TSuccessEventType;
     }> | Extract<import("../events/filters.js").IDashboardMeasureValueFilterRemoved, {
@@ -398,8 +402,12 @@ export declare const useDashboardCommandProcessing: <TCommand extends DashboardC
         type: TErrorEventType;
     }> | Extract<import("../events/filters.js").IDashboardMeasureValueFilterAdded, {
         type: TErrorEventType;
+    }> | Extract<import("../events/filters.js").IDashboardMeasureValueFilterConditionChanged, {
+        type: TErrorEventType;
     }> | Extract<import("../events/filters.js").IDashboardMeasureValueFilterConfigModeChanged, {
         type: TErrorEventType;
+    }> | Extract<import("../events/filters.js").IDashboardMeasureValueFilterDimensionalityChanged, {
+        type: TErrorEventType;
     }> | Extract<import("../events/filters.js").IDashboardMeasureValueFilterMoved, {
         type: TErrorEventType;
     }> | Extract<import("../events/filters.js").IDashboardMeasureValueFilterRemoved, {

package/esm/model/store/tabs/filterContext/filterContextReducers.d.ts

@@ -247,6 +247,10 @@ type IChangeMeasureValueFilterTitleReducerPayload = {
     readonly filterLocalId: string;
     readonly title?: string;
 };
+type ISetMeasureValueFilterDimensionalityReducerPayload = {
+    readonly localIdentifier: string;
+    readonly dimensionality?: ObjRef[];
+};
 export declare const filterContextReducers: {
     setFilterContext: FilterContextReducer<{
         payload: SetFilterContextPayload;
@@ -372,6 +376,10 @@ export declare const filterContextReducers: {
         payload: IChangeMeasureValueFilterConditionReducerPayload;
         type: string;
     }>;
+    setMeasureValueFilterDimensionality: FilterContextReducer<{
+        payload: ISetMeasureValueFilterDimensionalityReducerPayload;
+        type: string;
+    }>;
     changeMeasureValueFilterTitle: FilterContextReducer<{
         payload: IChangeMeasureValueFilterTitleReducerPayload;
         type: string;

package/esm/model/store/tabs/filterContext/filterContextReducers.js

@@ -866,6 +866,27 @@ const changeMeasureValueFilterCondition = (state, action) => {
         },
     };
 };
+const setMeasureValueFilterDimensionality = (state, action) => {
+    const activeTab = getActiveTab(state);
+    if (!activeTab) {
+        return;
+    }
+    invariant(activeTab.filterContext?.filterContextDefinition?.filters, "Attempt to edit uninitialized filter context");
+    const filters = activeTab.filterContext.filterContextDefinition.filters;
+    const index = filters.findIndex((item) => isDashboardMeasureValueFilter(item) &&
+        dashboardFilterLocalIdentifier(item) === action.payload.localIdentifier);
+    invariant(index >= 0, `Attempt to change dimensionality of measure value filter ${action.payload.localIdentifier} that does not exist`);
+    const filter = filters[index];
+    const dimensionality = action.payload.dimensionality && action.payload.dimensionality.length > 0
+        ? action.payload.dimensionality
+        : undefined;
+    filters[index] = {
+        dashboardMeasureValueFilter: {
+            ...filter.dashboardMeasureValueFilter,
+            dimensionality,
+        },
+    };
+};
 const changeMeasureValueFilterTitle = (state, action) => {
     const activeTab = getActiveTab(state);
     if (!activeTab) {
@@ -919,5 +940,6 @@ export const filterContextReducers = {
     resetWorkingSelection,
     setDefaultFilterOverrides,
     changeMeasureValueFilterCondition,
+    setMeasureValueFilterDimensionality,
     changeMeasureValueFilterTitle,
 };

package/esm/model/store/tabs/filterContext/filterContextState.d.ts

@@ -1,5 +1,5 @@
 import { type IAttributeWithReferences } from "@gooddata/sdk-backend-spi";
-import { type FilterContextItem, type IAttributeDisplayFormMetadataObject, type IDashboardAttributeFilter, type IDashboardDateFilter, type IDashboardObjectIdentity, type IFilterContextDefinition, type MeasureValueFilterCondition } from "@gooddata/sdk-model";
+import { type FilterContextItem, type IAttributeDisplayFormMetadataObject, type IDashboardAttributeFilter, type IDashboardDateFilter, type IDashboardObjectIdentity, type IFilterContextDefinition, type MeasureValueFilterCondition, type ObjRef } from "@gooddata/sdk-model";
 /**
  * Partial working attribute filter used in working filter context.
  *
@@ -17,6 +17,7 @@ export type WorkingDashboardMeasureValueFilter = {
     dashboardMeasureValueFilter: {
         localIdentifier: string;
         conditions?: MeasureValueFilterCondition[];
+        dimensionality?: ObjRef[];
     };
 };
 /**

package/esm/model/store/tabs/index.d.ts

@@ -238,6 +238,13 @@ export declare const tabsActions: import("@reduxjs/toolkit").CaseReducerActions<
         payload: import("./filterContext/filterContextReducers.js").IChangeMeasureValueFilterConditionReducerPayload;
         type: string;
     }) => void | import("./tabsState.js").ITabsState | import("immer").WritableDraft<import("./tabsState.js").ITabsState>;
+    readonly setMeasureValueFilterDimensionality: (state: import("immer").WritableDraft<import("./tabsState.js").ITabsState>, action: {
+        payload: {
+            readonly localIdentifier: string;
+            readonly dimensionality?: import("@gooddata/sdk-model").ObjRef[] | undefined;
+        };
+        type: string;
+    }) => void | import("./tabsState.js").ITabsState | import("immer").WritableDraft<import("./tabsState.js").ITabsState>;
     readonly changeMeasureValueFilterTitle: (state: import("immer").WritableDraft<import("./tabsState.js").ITabsState>, action: {
         payload: {
             readonly filterLocalId: string;

package/esm/presentation/automations/alerting/DefaultAlertingDialog/DefaultAlertingDialog.js

@@ -63,7 +63,7 @@ export function AlertingDialogRenderer({ alertToEdit, users, usersError, notific
         automationToEdit: alertToEdit,
         widget,
     });
-    const { onTitleChange, onRecipientsChange, onFiltersChange, onApplyCurrentFilters, onMeasureChange, getAttributeValues, onAttributeChange, onComparisonOperatorChange, onRelativeOperatorChange, onAnomalyDetectionChange, onChange, onBlur, onComparisonTypeChange, onDestinationChange, onTriggerModeChange, onTriggerIntervalChange, selectedMeasure, supportedMeasures, canManageAttributes, selectedAttribute, selectedValue, supportedAttributes, catalogAttributes, catalogDateDatasets, isResultLoading, selectedComparisonOperator, selectedRelativeOperator, selectedAiOperator, value, selectedComparator, selectedSensitivity, onSensitivityChange, selectedGranularity, onGranularityChange, canManageComparison, separators, defaultUser, originalAutomation, editedAutomation, allowOnlyLoggedUserRecipients, allowExternalRecipients, warningMessage, validationErrorMessage, isSubmitDisabled, isParentValid, thresholdErrorMessage, allowHourlyRecurrence, } = useEditAlert({
+    const { onTitleChange, onRecipientsChange, onFiltersChange, onApplyCurrentFilters, onMeasureChange, getAttributeValues, onAttributeChange, onComparisonOperatorChange, onRelativeOperatorChange, onAnomalyDetectionChange, onChange, onBlur, onComparisonTypeChange, onDestinationChange, onTriggerModeChange, onTriggerIntervalChange, selectedMeasure, canChangeMeasure, supportedMeasures, canManageAttributes, selectedAttribute, selectedValue, supportedAttributes, catalogAttributes, catalogDateDatasets, isResultLoading, selectedComparisonOperator, selectedRelativeOperator, selectedAiOperator, value, selectedComparator, selectedSensitivity, onSensitivityChange, selectedGranularity, onGranularityChange, canManageComparison, separators, defaultUser, originalAutomation, editedAutomation, allowOnlyLoggedUserRecipients, allowExternalRecipients, warningMessage, validationErrorMessage, isInvalidConnectionToInsight, isSubmitDisabled, isParentValid, thresholdErrorMessage, allowHourlyRecurrence, } = useEditAlert({
         insight,
         widget,
         alertToEdit,
@@ -118,10 +118,14 @@ export function AlertingDialogRenderer({ alertToEdit, users, usersError, notific
     const invalidDatapoints = getInvalidDatapoints();
     useEffect(() => {
         setInvalidDatapoints(() => [
-            !!validationErrorMessage && createInvalidDatapoint({ message: validationErrorMessage }),
+            !!validationErrorMessage &&
+                createInvalidDatapoint({
+                    message: validationErrorMessage,
+                    severity: isInvalidConnectionToInsight ? "error" : "warning",
+                }),
             !!thresholdErrorMessage && createInvalidDatapoint({ message: thresholdErrorMessage }),
         ]);
-    }, [validationErrorMessage, thresholdErrorMessage, setInvalidDatapoints]);
+    }, [validationErrorMessage, thresholdErrorMessage, isInvalidConnectionToInsight, setInvalidDatapoints]);
     const helpTextId = isMobileView()
         ? defineMessage({ id: "dialogs.alerting.footer.title.short" }).id
         : defineMessage({ id: "dialogs.alerting.footer.title" }).id;
@@ -164,10 +168,10 @@ export function AlertingDialogRenderer({ alertToEdit, users, usersError, notific
                                         _jsx("div", { className: "gd-divider-with-margin" }), _jsxs(_Fragment, { children: [
                                                 _jsx(AutomationFiltersSelect, { availableFilters: availableFilters, selectedFilters: editedAutomationFilters, onFiltersChange: onFiltersChange, storeFilters: true, onStoreFiltersChange: () => { }, isDashboardAutomation: false, overlayPositionType: OVERLAY_POSITION_TYPE, disableDateFilters: isAnomalyDetection(editedAutomation?.alert) }), _jsx(ContentDivider, { className: "gd-divider-with-margin" })
                                             ] }), _jsxs(FormFieldGroup, { label: _jsx(FormattedMessage, { id: "insightAlert.config.when" }), children: [
-                                                _jsx(FormField, { label: intl.formatMessage({ id: "insightAlert.config.metric" }), htmlFor: "alert.measure", children: _jsx(AlertMeasureSelect, { selectedMeasure: selectedMeasure, onMeasureChange: onMeasureChange, measures: supportedMeasures, overlayPositionType: OVERLAY_POSITION_TYPE, id: "alert.measure", closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) }), Boolean(canManageAttributes) &&
+                                                _jsx(FormField, { label: intl.formatMessage({ id: "insightAlert.config.metric" }), htmlFor: "alert.measure", children: _jsx(AlertMeasureSelect, { selectedMeasure: selectedMeasure, onMeasureChange: onMeasureChange, measures: supportedMeasures, disabled: !canChangeMeasure, overlayPositionType: OVERLAY_POSITION_TYPE, id: "alert.measure", closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) }), Boolean(canManageAttributes) &&
                                                     supportedAttributes.filter((a) => a.type === "attribute").length >
-                                                        0 && (_jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.for" }), htmlFor: "alert.attribute", children: _jsx(AlertAttributeSelect, { id: "alert.attribute", selectedAttribute: selectedAttribute, selectedValue: selectedValue, onAttributeChange: onAttributeChange, attributes: supportedAttributes, catalogAttributes: catalogAttributes, catalogDateDatasets: catalogDateDatasets, getAttributeValues: getAttributeValues, isResultLoading: isResultLoading, showLabel: false, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) })), _jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.condition" }), htmlFor: "alert.condition", children: _jsx(AlertComparisonOperatorSelect, { id: "alert.condition", measure: selectedMeasure, enableAnomalyDetectionAlert: enableAnomalyDetectionAlert ? enableAiAssistant : false, selectedComparisonOperator: selectedComparisonOperator, selectedRelativeOperator: selectedRelativeOperator, selectedAiOperator: selectedAiOperator, onAnomalyDetectionChange: onAnomalyDetectionChange, onComparisonOperatorChange: onComparisonOperatorChange, onRelativeOperatorChange: onRelativeOperatorChange, overlayPositionType: OVERLAY_POSITION_TYPE, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) }), !isAnomalyDetection(editedAutomation?.alert) && (_jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.threshold" }), htmlFor: "alert.value", children: _jsx(AlertThresholdInput, { id: "alert.value", value: value, onChange: onChange, onBlur: onBlur, suffix: getValueSuffix(editedAutomation?.alert), errorMessage: thresholdErrorMessage }) })), isChangeOrDifferenceOperator(editedAutomation?.alert) && (_jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.comparison" }), htmlFor: "alert.comparison", children: _jsx(AlertComparisonPeriodSelect, { id: "alert.comparison", measure: selectedMeasure, alert: editedAutomation, selectedComparison: selectedComparator?.comparator, onComparisonChange: (comparisonType) => {
-                                                            onComparisonTypeChange(selectedMeasure, selectedRelativeOperator, comparisonType);
+                                                        0 && (_jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.for" }), htmlFor: "alert.attribute", children: _jsx(AlertAttributeSelect, { id: "alert.attribute", disabled: !canChangeMeasure, selectedAttribute: selectedAttribute, selectedValue: selectedValue, onAttributeChange: onAttributeChange, attributes: supportedAttributes, catalogAttributes: catalogAttributes, catalogDateDatasets: catalogDateDatasets, getAttributeValues: getAttributeValues, isResultLoading: isResultLoading, showLabel: false, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) })), _jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.condition" }), htmlFor: "alert.condition", children: _jsx(AlertComparisonOperatorSelect, { id: "alert.condition", measure: selectedMeasure, enableAnomalyDetectionAlert: enableAnomalyDetectionAlert ? enableAiAssistant : false, selectedComparisonOperator: selectedComparisonOperator, selectedRelativeOperator: selectedRelativeOperator, selectedAiOperator: selectedAiOperator, onAnomalyDetectionChange: onAnomalyDetectionChange, onComparisonOperatorChange: onComparisonOperatorChange, onRelativeOperatorChange: onRelativeOperatorChange, overlayPositionType: OVERLAY_POSITION_TYPE, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) }), !isAnomalyDetection(editedAutomation?.alert) && (_jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.threshold" }), htmlFor: "alert.value", children: _jsx(AlertThresholdInput, { id: "alert.value", value: value, onChange: onChange, onBlur: onBlur, suffix: getValueSuffix(editedAutomation?.alert), errorMessage: thresholdErrorMessage }) })), isChangeOrDifferenceOperator(editedAutomation?.alert) && (_jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.comparison" }), htmlFor: "alert.comparison", children: _jsx(AlertComparisonPeriodSelect, { id: "alert.comparison", measure: selectedMeasure, alert: editedAutomation, selectedComparison: selectedComparator?.comparator, selectedGranularity: selectedComparator?.granularity, onComparisonChange: (comparisonType, granularity) => {
+                                                            onComparisonTypeChange(selectedMeasure, selectedRelativeOperator, comparisonType, granularity);
                                                         }, overlayPositionType: OVERLAY_POSITION_TYPE, canManageComparison: canManageComparison, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) })), isAnomalyDetection(editedAutomation?.alert) && (_jsxs(_Fragment, { children: [
                                                         _jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.sensitivity" }), htmlFor: "alert.sensitivity", children: _jsx(AlertSensitivitySelect, { id: "alert.sensitivity", selectedSensitivity: selectedSensitivity, onSensitivityChange: onSensitivityChange, overlayPositionType: OVERLAY_POSITION_TYPE, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) }), _jsx(FormField, { label: _jsxs("div", { className: "gd-dashboard-alerting-dialog-form-field__content-container-tooltip", children: [
                                                                     _jsx(FormattedMessage, { id: "insightAlert.config.granularity" }), _jsx(UiTooltip, { anchor: _jsx(UiIconButton, { icon: "question", variant: "tertiary", size: "xsmall", accessibilityConfig: {
@@ -185,7 +189,7 @@ export function AlertingDialogRenderer({ alertToEdit, users, usersError, notific
                                                                         }),
                                                                     } }), content: _jsx(FormattedMessage, { id: "insightAlert.config.interval.tooltip" }), arrowPlacement: "left", optimalPlacement: true, offset: 10, width: 280, triggerBy: ["hover", "click"] })
                                                         ] }), htmlFor: "alert.interval", children: _jsx(AlertTriggerIntervalSelect, { id: "alert.interval", selectedTriggerInterval: editedAutomation?.alert?.trigger.interval ?? "DAY", onTriggerIntervalChange: onTriggerIntervalChange, overlayPositionType: OVERLAY_POSITION_TYPE, closeOnParentScroll: CLOSE_ON_PARENT_SCROLL }) })) : null, _jsx(FormField, { label: _jsx(FormattedMessage, { id: "insightAlert.config.recipients" }), htmlFor: "alert.recipients", fullWidth: true, children: _jsx(RecipientsSelect, { id: "alert.recipients", loggedUser: defaultUser, users: users, usersError: usersError, value: editedAutomation?.recipients ?? [], originalValue: originalAutomation?.recipients || [], onChange: onRecipientsChange, allowEmptySelection: true, allowOnlyLoggedUserRecipients: allowOnlyLoggedUserRecipients, allowExternalRecipients: allowExternalRecipients, maxRecipients: maxAutomationsRecipients, notificationChannels: notificationChannels, notificationChannelId: editedAutomation?.notificationChannel, showLabel: false, externalRecipientOverride: externalRecipientOverride }) })
-                                            ] }), warningMessage ? (_jsx(Message, { type: "warning", className: "gd-notifications-channels-dialog-error", children: warningMessage })) : null, invalidDatapoints.map((datapoint) => (_jsx(Message, { type: "error", id: datapoint.id, className: "gd-notifications-channels-dialog-error gd-notifications-channels-dialog-error-scrollable", children: datapoint.message }, datapoint.id)))] })
+                                            ] }), warningMessage ? (_jsx(Message, { type: "warning", className: "gd-notifications-channels-dialog-error", children: warningMessage })) : null, invalidDatapoints.map((datapoint) => (_jsx(Message, { id: datapoint.id, type: datapoint.severity === "info" ? "progress" : datapoint.severity, className: "gd-notifications-channels-dialog-error gd-notifications-channels-dialog-error-scrollable", children: datapoint.message }, datapoint.id)))] })
                             ] }) }) }) }), alertToDelete ? (_jsx(DeleteAlertConfirmDialog, { alert: alertToDelete, onCancel: () => setAlertToDelete(null), onSuccess: handleAlertDeleteSuccess, onError: onDeleteError })) : null] }));
 }
 /**

package/esm/presentation/automations/alerting/DefaultAlertingDialog/components/AlertAttributeSelect.d.ts

@@ -3,6 +3,7 @@ import { type AlertAttribute } from "../../types.js";
 import { type AttributeValue } from "../hooks/useAttributeValuesFromExecResults.js";
 export interface IAlertAttributeSelectProps {
     id: string;
+    disabled?: boolean;
     selectedAttribute: AlertAttribute | undefined;
     selectedValue: string | null | undefined;
     onAttributeChange: (attribute: AlertAttribute | undefined, value: AttributeValue | undefined) => void;
@@ -14,4 +15,4 @@ export interface IAlertAttributeSelectProps {
     showLabel?: boolean;
     closeOnParentScroll?: boolean;
 }
-export declare function AlertAttributeSelect({ id, selectedAttribute: selectedAttributeProp, getAttributeValues, isResultLoading, selectedValue, onAttributeChange, attributes, catalogAttributes, catalogDateDatasets, showLabel, closeOnParentScroll }: IAlertAttributeSelectProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function AlertAttributeSelect({ id, disabled, selectedAttribute: selectedAttributeProp, getAttributeValues, isResultLoading, selectedValue, onAttributeChange, attributes, catalogAttributes, catalogDateDatasets, showLabel, closeOnParentScroll }: IAlertAttributeSelectProps): import("react/jsx-runtime").JSX.Element | null;

package/esm/presentation/automations/alerting/DefaultAlertingDialog/components/AlertAttributeSelect.js

@@ -54,7 +54,7 @@ function AttributeValuesSearchContent({ attribute, values, isSelected, selectedA
                     }, children: _jsx("div", { className: "gd-alert-attribute-select__menu-item s-menu-alert-attribute-item-value", children: (value.title ?? value.name) || `(${intl.formatMessage({ id: "empty_value" })})` }) }, index))) })
         ] }));
 }
-export function AlertAttributeSelect({ id, selectedAttribute: selectedAttributeProp, getAttributeValues, isResultLoading, selectedValue, onAttributeChange, attributes, catalogAttributes, catalogDateDatasets, showLabel = true, closeOnParentScroll, }) {
+export function AlertAttributeSelect({ id, disabled, selectedAttribute: selectedAttributeProp, getAttributeValues, isResultLoading, selectedValue, onAttributeChange, attributes, catalogAttributes, catalogDateDatasets, showLabel = true, closeOnParentScroll, }) {
     const intl = useIntl();
     const availableAttributes = useMemo(() => {
         return attributes.filter((attr) => attr.type === "attribute");
@@ -135,10 +135,10 @@ export function AlertAttributeSelect({ id, selectedAttribute: selectedAttributeP
                         return (_jsx(DropdownButton, { id: id, className: cx("gd-alert-attribute-select__button", {
                                 "is-active": isOpen,
                             }), value: buttonValue, iconLeft: "gd-icon-attribute", onClick: () => {
-                                if (!isResultLoading) {
+                                if (!isResultLoading && !disabled) {
                                     toggleDropdown();
                                 }
-                            }, disabled: isResultLoading, buttonRef: buttonRef, dropdownId: dropdownId, isOpen: isOpen, accessibilityConfig: {
+                            }, disabled: isResultLoading || disabled, buttonRef: buttonRef, dropdownId: dropdownId, isOpen: isOpen, accessibilityConfig: {
                                 ariaExpanded: isOpen,
                                 popupType: "menu",
                             } }));

package/esm/presentation/automations/alerting/DefaultAlertingDialog/components/AlertComparisonPeriodSelect.d.ts

@@ -1,4 +1,4 @@
-import { type IAutomationMetadataObject } from "@gooddata/sdk-model";
+import { type DateAttributeGranularity, type IAutomationMetadataObject } from "@gooddata/sdk-model";
 import { type OverlayPositionType } from "@gooddata/sdk-ui-kit";
 import { type AlertMetric, AlertMetricComparatorType } from "../../types.js";
 export interface IAlertComparisonPeriodSelectProps {
@@ -6,9 +6,10 @@ export interface IAlertComparisonPeriodSelectProps {
     measure: AlertMetric | undefined;
     overlayPositionType?: OverlayPositionType;
     selectedComparison?: AlertMetricComparatorType;
-    onComparisonChange: (comparison: AlertMetricComparatorType) => void;
+    selectedGranularity?: DateAttributeGranularity;
+    onComparisonChange: (comparison: AlertMetricComparatorType, granularity?: DateAttributeGranularity) => void;
     canManageComparison: boolean;
     id: string;
     closeOnParentScroll?: boolean;
 }
-export declare function AlertComparisonPeriodSelect({ alert, measure, overlayPositionType, selectedComparison, canManageComparison, onComparisonChange, id, closeOnParentScroll }: IAlertComparisonPeriodSelectProps): import("react/jsx-runtime").JSX.Element | null;
+export declare function AlertComparisonPeriodSelect({ alert, measure, overlayPositionType, selectedComparison, selectedGranularity, canManageComparison, onComparisonChange, id, closeOnParentScroll }: IAlertComparisonPeriodSelectProps): import("react/jsx-runtime").JSX.Element | null;

package/esm/presentation/automations/alerting/DefaultAlertingDialog/components/AlertComparisonPeriodSelect.js

@@ -3,43 +3,73 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { useMemo } from "react";
 import cx from "classnames";
 import { useIntl } from "react-intl";
-import { DateGranularity } from "@gooddata/sdk-model";
+import { DateGranularity, } from "@gooddata/sdk-model";
 import { Dropdown, DropdownButton, SingleSelectListItem, UiListbox, } from "@gooddata/sdk-ui-kit";
 import { AlertMetricComparatorType } from "../../types.js";
 import { translateGranularity } from "../utils/granularity.js";
 import { isChangeOrDifferenceOperator } from "../utils/guards.js";
-export function AlertComparisonPeriodSelect({ alert, measure, overlayPositionType, selectedComparison, canManageComparison, onComparisonChange, id, closeOnParentScroll, }) {
+export function AlertComparisonPeriodSelect({ alert, measure, overlayPositionType, selectedComparison, selectedGranularity, canManageComparison, onComparisonChange, id, closeOnParentScroll, }) {
     const intl = useIntl();
     const selectedOperator = useMemo(() => {
-        return measure?.comparators.find((a) => a.comparator === selectedComparison);
-    }, [measure?.comparators, selectedComparison]);
+        return measure?.comparators.find((a) => a.comparator === selectedComparison &&
+            (selectedGranularity ? selectedGranularity === a.granularity : true));
+    }, [measure?.comparators, selectedComparison, selectedGranularity]);
     const comparisons = useMemo(() => {
-        const sp = measure?.comparators.find((a) => a.comparator === AlertMetricComparatorType.SamePeriodPreviousYear);
-        const pp = measure?.comparators.find((a) => a.comparator === AlertMetricComparatorType.PreviousPeriod);
-        return [
-            sp?.granularity && pp?.granularity !== DateGranularity["year"]
-                ? {
-                    title: intl.formatMessage({ id: "insightAlert.config.compare_with_sp_granularity" }, {
-                        period: translateGranularity(intl, sp.granularity),
-                    }),
-                    type: AlertMetricComparatorType.SamePeriodPreviousYear,
+        const sps = measure?.comparators.filter((a) => a.comparator === AlertMetricComparatorType.SamePeriodPreviousYear) ?? [];
+        const pps = measure?.comparators.filter((a) => a.comparator === AlertMetricComparatorType.PreviousPeriod) ??
+            [];
+        const items = [];
+        // Iterate over SamePeriodPreviousYear comparators
+        sps.forEach((sp) => {
+            const pp = pps.find((pp) => pp.granularity === sp.granularity);
+            // Has granularity set and previous period is not year
+            if (sp.granularity) {
+                if (pp?.granularity === DateGranularity["year"]) {
+                    items.push({
+                        title: intl.formatMessage({ id: "insightAlert.config.compare_with_sp" }),
+                        type: AlertMetricComparatorType.SamePeriodPreviousYear,
+                        granularity: sp.granularity,
+                    });
                 }
-                : {
+                else {
+                    items.push({
+                        title: intl.formatMessage({ id: "insightAlert.config.compare_with_sp_granularity" }, {
+                            period: translateGranularity(intl, sp.granularity),
+                        }),
+                        type: AlertMetricComparatorType.SamePeriodPreviousYear,
+                        granularity: sp.granularity,
+                    });
+                }
+            }
+            else {
+                items.push({
                     title: intl.formatMessage({ id: "insightAlert.config.compare_with_sp" }),
                     type: AlertMetricComparatorType.SamePeriodPreviousYear,
-                },
-            pp?.granularity
-                ? {
+                    granularity: undefined,
+                });
+            }
+        });
+        // Iterate over PreviousPeriod comparators
+        pps.forEach((pp) => {
+            // Previous period has granularity set
+            if (pp.granularity) {
+                items.push({
                     title: intl.formatMessage({ id: "insightAlert.config.compare_with_pp_granularity" }, {
                         period: translateGranularity(intl, pp.granularity),
                     }),
                     type: AlertMetricComparatorType.PreviousPeriod,
-                }
-                : {
+                    granularity: pp.granularity,
+                });
+            }
+            else {
+                items.push({
                     title: intl.formatMessage({ id: "insightAlert.config.compare_with_pp" }),
                     type: AlertMetricComparatorType.PreviousPeriod,
-                },
-        ];
+                    granularity: undefined,
+                });
+            }
+        });
+        return items;
     }, [intl, measure?.comparators]);
     // If alert is not defined or the measure does not have any comparators, return null
     if (!alert || !isChangeOrDifferenceOperator(alert.alert)) {
@@ -62,13 +92,14 @@ export function AlertComparisonPeriodSelect({ alert, measure, overlayPositionTyp
         }, renderBody: ({ closeDropdown, ariaAttributes }) => {
             const listboxItems = comparisons.map((comparison) => ({
                 type: "interactive",
-                id: comparison.type.toString(),
+                id: `${comparison.type}-${comparison.granularity ?? "none"}`,
                 stringTitle: comparison.title,
                 data: comparison,
             }));
-            return (_jsx(UiListbox, { shouldKeyboardActionStopPropagation: true, shouldKeyboardActionPreventDefault: true, dataTestId: "s-alert-comparison-select-list", items: listboxItems, selectedItemId: selectedComparison?.toString(), onSelect: (item) => {
-                    if (item.data.type !== selectedComparison) {
-                        onComparisonChange(item.data.type);
+            return (_jsx(UiListbox, { shouldKeyboardActionStopPropagation: true, shouldKeyboardActionPreventDefault: true, dataTestId: "s-alert-comparison-select-list", items: listboxItems, selectedItemId: `${selectedComparison ?? "none"}-${selectedGranularity ?? "none"}`, onSelect: (item) => {
+                    if (item.data.type !== selectedComparison ||
+                        item.data.granularity !== selectedGranularity) {
+                        onComparisonChange(item.data.type, item.data.granularity);
                     }
                 }, onClose: closeDropdown, ariaAttributes: ariaAttributes, InteractiveItemComponent: ({ item, isSelected, onSelect, isFocused }) => {
                     return (_jsx(SingleSelectListItem, { title: item.stringTitle, isSelected: isSelected, isFocused: isFocused, onClick: onSelect, className: "gd-alert-comparison-select__list-item" }));

package/esm/presentation/automations/alerting/DefaultAlertingDialog/components/AlertMeasureSelect.d.ts

@@ -2,10 +2,11 @@ import { type OverlayPositionType } from "@gooddata/sdk-ui-kit";
 import { type AlertMetric } from "../../types.js";
 export interface IAlertMetricSelectProps {
     id?: string;
+    disabled?: boolean;
     selectedMeasure: AlertMetric | undefined;
     onMeasureChange: (measure: AlertMetric) => void;
     measures: AlertMetric[];
     overlayPositionType?: OverlayPositionType;
     closeOnParentScroll?: boolean;
 }
-export declare function AlertMeasureSelect({ id, selectedMeasure, onMeasureChange, measures, overlayPositionType, closeOnParentScroll }: IAlertMetricSelectProps): import("react/jsx-runtime").JSX.Element;
+export declare function AlertMeasureSelect({ id, disabled, selectedMeasure, onMeasureChange, measures, overlayPositionType, closeOnParentScroll }: IAlertMetricSelectProps): import("react/jsx-runtime").JSX.Element;

package/esm/presentation/automations/alerting/DefaultAlertingDialog/components/AlertMeasureSelect.js

@@ -6,7 +6,7 @@ import { useIntl } from "react-intl";
 import { Dropdown, DropdownButton, SingleSelectListItem, UiListbox, } from "@gooddata/sdk-ui-kit";
 import { getMeasureTitle } from "../utils/getters.js";
 const measureIcon = _jsx("div", { className: "gd-alert-measure-select__icon gd-icon-metric" });
-export function AlertMeasureSelect({ id, selectedMeasure, onMeasureChange, measures, overlayPositionType, closeOnParentScroll, }) {
+export function AlertMeasureSelect({ id, disabled, selectedMeasure, onMeasureChange, measures, overlayPositionType, closeOnParentScroll, }) {
     const intl = useIntl();
     const ref = useRef(null);
     const selectedMeasureTitle = selectedMeasure
@@ -15,7 +15,7 @@ export function AlertMeasureSelect({ id, selectedMeasure, onMeasureChange, measu
     return (_jsx(Dropdown, { closeOnParentScroll: closeOnParentScroll, overlayPositionType: overlayPositionType, autofocusOnOpen: true, renderButton: ({ isOpen, toggleDropdown, buttonRef, dropdownId }) => {
             return (_jsx("div", { ref: (item) => {
                     ref.current = item;
-                }, children: _jsx(DropdownButton, { id: id, className: cx("gd-alert-measure-select__button s-alert-measure-select"), value: selectedMeasureTitle, iconLeft: selectedMeasure ? "gd-icon-metric" : undefined, onClick: toggleDropdown, buttonRef: buttonRef, dropdownId: dropdownId, isOpen: isOpen, accessibilityConfig: {
+                }, children: _jsx(DropdownButton, { id: id, disabled: disabled, className: cx("gd-alert-measure-select__button s-alert-measure-select"), value: selectedMeasureTitle, iconLeft: selectedMeasure ? "gd-icon-metric" : undefined, onClick: toggleDropdown, buttonRef: buttonRef, dropdownId: dropdownId, isOpen: isOpen, accessibilityConfig: {
                         ariaExpanded: isOpen,
                         popupType: "listbox",
                     } }) }));

package/esm/presentation/automations/alerting/DefaultAlertingDialog/hooks/useAlertValidation.js

@@ -1,6 +1,7 @@
 // (C) 2024-2026 GoodData Corporation
 import { useDashboardSelector } from "../../../../../model/react/DashboardStoreProvider.js";
 import { selectCatalogDateDatasets } from "../../../../../model/store/catalog/catalogSelectors.js";
+import { selectEnableComparisonInAlerting } from "../../../../../model/store/config/configSelectors.js";
 import { selectInsightByWidgetRef } from "../../../../../model/store/insights/insightsSelectors.js";
 import { selectWidgetByRef } from "../../../../../model/store/tabs/layout/layoutSelectors.js";
 import { getAlertMeasure } from "../utils/getters.js";
@@ -8,10 +9,11 @@ import { getSupportedInsightMeasuresByInsight } from "../utils/items.js";
 export const useAlertValidation = (alert, isNewAlert) => {
     const widgetLocalId = alert?.metadata?.widget;
     const widgetRef = widgetLocalId ? { identifier: widgetLocalId } : undefined;
+    const canManageComparison = useDashboardSelector(selectEnableComparisonInAlerting);
     const widget = useDashboardSelector(selectWidgetByRef(widgetRef));
     const insight = useDashboardSelector(selectInsightByWidgetRef(widget?.ref));
     const dateDatasets = useDashboardSelector(selectCatalogDateDatasets);
-    const supportedMeasures = getSupportedInsightMeasuresByInsight(insight, dateDatasets);
+    const supportedMeasures = getSupportedInsightMeasuresByInsight(insight, dateDatasets, canManageComparison, alert);
     const selectedMeasureExists = alert ? getAlertMeasure(supportedMeasures, alert.alert) : undefined;
     const isValid = isNewAlert || Boolean(!!widget && selectedMeasureExists);
     let invalidityReason = undefined;

package/esm/presentation/automations/alerting/DefaultAlertingDialog/hooks/useEditAlert.d.ts

@@ -1,4 +1,4 @@
-import { type FilterContextItem, type IAlertAnomalyDetectionGranularity, type IAlertAnomalyDetectionSensitivity, type IAlertComparisonOperator, type IAlertRelativeArithmeticOperator, type IAlertRelativeOperator, type IAlertTriggerInterval, type IAlertTriggerMode, type IAutomationMetadataObject, type IAutomationMetadataObjectDefinition, type IAutomationRecipient, type IAutomationVisibleFilter, type IInsight, type INotificationChannelIdentifier, type INotificationChannelMetadataObject } from "@gooddata/sdk-model";
+import { type DateAttributeGranularity, type FilterContextItem, type IAlertAnomalyDetectionGranularity, type IAlertAnomalyDetectionSensitivity, type IAlertComparisonOperator, type IAlertRelativeArithmeticOperator, type IAlertRelativeOperator, type IAlertTriggerInterval, type IAlertTriggerMode, type IAutomationMetadataObject, type IAutomationMetadataObjectDefinition, type IAutomationRecipient, type IAutomationVisibleFilter, type IInsight, type INotificationChannelIdentifier, type INotificationChannelMetadataObject } from "@gooddata/sdk-model";
 import type { ExtendedDashboardWidget } from "../../../../../model/types/layoutTypes.js";
 import { type AlertAttribute, type AlertMetric, type AlertMetricComparatorType } from "../../types.js";
 export interface IUseEditAlertProps {
@@ -32,11 +32,12 @@ export declare function useEditAlert({ alertToEdit, notificationChannels, insigh
     onGranularityChange: (measure: AlertMetric | undefined, granularity: IAlertAnomalyDetectionGranularity) => void;
     onChange: (e: string | number, event?: import("react").ChangeEvent<HTMLInputElement> | undefined) => void;
     onBlur: (event: import("react").FocusEvent<HTMLInputElement, Element>) => void;
-    onComparisonTypeChange: (measure: AlertMetric | undefined, relativeOperator: [IAlertRelativeOperator, IAlertRelativeArithmeticOperator] | undefined, comparisonType: AlertMetricComparatorType) => void;
+    onComparisonTypeChange: (measure: AlertMetric | undefined, relativeOperator: [IAlertRelativeOperator, IAlertRelativeArithmeticOperator] | undefined, comparisonType: AlertMetricComparatorType, granularity?: DateAttributeGranularity | undefined) => void;
     onDestinationChange: (destinationId: string) => void;
     onTriggerModeChange: (triggerMode: IAlertTriggerMode) => void;
     onTriggerIntervalChange: (triggerInterval: IAlertTriggerInterval, dirty?: boolean) => void;
     selectedMeasure: AlertMetric | undefined;
+    canChangeMeasure: boolean;
     supportedMeasures: AlertMetric[];
     canManageAttributes: boolean;
     selectedAttribute: AlertAttribute | undefined;
@@ -45,6 +46,7 @@ export declare function useEditAlert({ alertToEdit, notificationChannels, insigh
     catalogAttributes: import("@gooddata/sdk-model").ICatalogAttribute[];
     catalogDateDatasets: import("@gooddata/sdk-model").ICatalogDateDataset[];
     isResultLoading: boolean;
+    isInvalidConnectionToInsight: "" | boolean | undefined;
     selectedAiOperator: "AI.ANOMALY_DETECTION" | undefined;
     selectedSensitivity: IAlertAnomalyDetectionSensitivity | undefined;
     selectedGranularity: IAlertAnomalyDetectionGranularity | undefined;

package/esm/presentation/automations/alerting/DefaultAlertingDialog/hooks/useEditAlert.js

@@ -47,6 +47,7 @@ export function useEditAlert({ alertToEdit, notificationChannels, insight, widge
     const commonDateFilterId = useDashboardSelector(selectAutomationCommonDateFilterId);
     const weekStart = useDashboardSelector(selectWeekStart);
     const timezone = useDashboardSelector(selectTimezone);
+    const isInvalidConnectionToInsight = alertToEdit?.metadata?.widget && !insight;
     const minimumRecurrenceMinutesEntitlement = useDashboardSelector(selectEntitlementMinimumRecurrenceMinutes);
     const allowHourlyRecurrence = parseInt(minimumRecurrenceMinutesEntitlement?.value ?? DEFAULT_MIN_RECURRENCE_MINUTES, 10) === 60;
     const widgetTabMap = useDashboardSelector(selectWidgetLocalIdToTabIdMap);
@@ -63,8 +64,8 @@ export function useEditAlert({ alertToEdit, notificationChannels, insight, widge
     const measureFormatMap = useMemo(() => {
         return getMeasureFormatsFromExecution(execResult?.executionResult);
     }, [execResult?.executionResult]);
-    const supportedMeasures = useMemo(() => getSupportedInsightMeasuresByInsight(effectiveInsight, catalogDateDatasets, canManageComparison), [effectiveInsight, catalogDateDatasets, canManageComparison]);
-    const supportedAttributes = useMemo(() => getSupportedInsightAttributesByInsight(insight, catalogDateDatasets), [insight, catalogDateDatasets]);
+    const supportedMeasures = useMemo(() => getSupportedInsightMeasuresByInsight(effectiveInsight, catalogDateDatasets, canManageComparison, alertToEdit), [effectiveInsight, catalogDateDatasets, canManageComparison, alertToEdit]);
+    const supportedAttributes = useMemo(() => getSupportedInsightAttributesByInsight(insight, catalogAttributes, catalogDateDatasets, alertToEdit), [insight, catalogDateDatasets, catalogAttributes, alertToEdit]);
     const { isResultLoading, getAttributeValues, getMetricValue } = useAttributeValuesFromExecResults(execResult);
     // Default values
     const defaultMeasure = supportedMeasures[0];
@@ -158,13 +159,13 @@ export function useEditAlert({ alertToEdit, notificationChannels, insight, widge
         setTriggerIntervalDirty(false);
         setEditedAutomation((alert) => transformAlertByAnomalyDetection(supportedMeasures, alert, measure, weekStart, timezone, enableAlertOncePerInterval));
     }, [supportedMeasures, weekStart, timezone, enableAlertOncePerInterval]);
-    const onComparisonTypeChange = useCallback((measure, relativeOperator, comparisonType) => {
+    const onComparisonTypeChange = useCallback((measure, relativeOperator, comparisonType, granularity) => {
         if (!measure || !relativeOperator || !relativeOperator) {
             return;
         }
         const [relativeOperatorValue, arithmeticOperator] = relativeOperator;
         setEditedAutomation((alert) => alert
-            ? transformAlertByRelativeOperator(supportedMeasures, alert, measure, relativeOperatorValue, arithmeticOperator, measureFormatMap, comparisonType)
+            ? transformAlertByRelativeOperator(supportedMeasures, alert, measure, relativeOperatorValue, arithmeticOperator, measureFormatMap, comparisonType, granularity)
             : undefined);
     }, [measureFormatMap, supportedMeasures]);
     const onSensitivityChange = useCallback((sensitivity) => {
@@ -283,7 +284,9 @@ export function useEditAlert({ alertToEdit, notificationChannels, insight, widge
     const hasValidThreshold = isAlertValueDefined(editedAutomation?.alert);
     const validationErrorMessage = isOriginalAutomationValid
         ? undefined
-        : intl.formatMessage({ id: "insightAlert.config.invalidWidget" });
+        : isInvalidConnectionToInsight
+            ? intl.formatMessage({ id: "insightAlert.config.invalidWidget" })
+            : intl.formatMessage({ id: "insightAlert.config.unusedWidget" });
     const hasRecipients = (editedAutomation?.recipients?.length ?? 0) > 0;
     const hasValidExternalRecipients = allowExternalRecipients
         ? true
@@ -327,6 +330,7 @@ export function useEditAlert({ alertToEdit, notificationChannels, insight, widge
         onTriggerModeChange,
         onTriggerIntervalChange,
         selectedMeasure,
+        canChangeMeasure: !!insight,
         supportedMeasures,
         canManageAttributes,
         selectedAttribute,
@@ -335,6 +339,7 @@ export function useEditAlert({ alertToEdit, notificationChannels, insight, widge
         catalogAttributes,
         catalogDateDatasets,
         isResultLoading,
+        isInvalidConnectionToInsight,
         selectedAiOperator,
         selectedSensitivity,
         selectedGranularity,

package/esm/presentation/automations/alerting/DefaultAlertingDialog/utils/getters.js

@@ -212,7 +212,14 @@ export function getSelectedCatalogAttributeValue(attribute, getAttributeValue, s
     }
     const values = getAttributeValue(attribute);
     return (values.find((value) => value.name === selectedValue) ??
-        values.find((value) => value.value === selectedValue));
+        values.find((value) => value.value === selectedValue) ??
+        (selectedValue
+            ? {
+                title: selectedValue,
+                value: selectedValue,
+                name: selectedValue,
+            }
+            : undefined));
 }
 /**
  * @internal

package/esm/presentation/automations/alerting/DefaultAlertingDialog/utils/items.d.ts

@@ -1,15 +1,18 @@
-import { type ICatalogDateDataset, type IInsight } from "@gooddata/sdk-model";
+import { type IAutomationMetadataObject, type ICatalogAttribute, type ICatalogDateDataset, type IInsight } from "@gooddata/sdk-model";
 import { type AlertAttribute, type AlertMetric } from "../../types.js";
 /**
  * Get supported insight measures by insight
  * @param insight - insight to get supported measures for
  * @param dateDatasets - date datasets to filter out date attributes
  * @param canManageComparison - flag if user can manage comparison
+ * @param alert - alert to get supported measures for
  */
-export declare function getSupportedInsightMeasuresByInsight(insight: IInsight | null | undefined, dateDatasets?: ICatalogDateDataset[], canManageComparison?: boolean): AlertMetric[];
+export declare function getSupportedInsightMeasuresByInsight(insight: IInsight | null | undefined, dateDatasets?: ICatalogDateDataset[], canManageComparison?: boolean, alert?: IAutomationMetadataObject): AlertMetric[];
 /**
  * Get supported insight attributes by insight
  * @param insight - insight to get supported attributes for
+ * @param attributes - attributes to filter out date attributes
  * @param dateDatasets - date datasets to filter out date attributes
+ * @param alert - alert metadata object
  */
-export declare function getSupportedInsightAttributesByInsight(insight: IInsight | null | undefined, dateDatasets?: ICatalogDateDataset[]): AlertAttribute[];
+export declare function getSupportedInsightAttributesByInsight(insight: IInsight | null | undefined, attributes: ICatalogAttribute[], dateDatasets?: ICatalogDateDataset[], alert?: IAutomationMetadataObject): AlertAttribute[];