Disable action types in UI when license doesn't support it

.sass-lint.yml

@@ -7,6 +7,7 @@ files:
     - 'x-pack/legacy/plugins/rollup/**/*.s+(a|c)ss'
     - 'x-pack/legacy/plugins/security/**/*.s+(a|c)ss'
     - 'x-pack/legacy/plugins/canvas/**/*.s+(a|c)ss'
+    - 'x-pack/plugins/triggers_actions_ui/**/*.s+(a|c)ss'
   ignore:
     - 'x-pack/legacy/plugins/canvas/shareable_runtime/**/*.s+(a|c)ss'
     - 'x-pack/legacy/plugins/lens/**/*.s+(a|c)ss'

x-pack/legacy/plugins/siem/public/pages/case/components/configure_cases/connectors.tsx

@@ -21,6 +21,7 @@ import * as i18n from './translations';
 import {
   ActionsConnectorsContextProvider,
   ConnectorAddFlyout,
+  ActionType,
 } from '../../../../../../../../plugins/triggers_actions_ui/public';
 import { Connector } from '../../../../containers/case/configure/types';
 import { useKibana } from '../../../../lib/kibana';
@@ -41,11 +42,14 @@ interface Props {
   refetchConnectors: () => void;
   selectedConnector: string;
 }
-const actionTypes = [
+const actionTypes: ActionType[] = [
   {
     id: '.servicenow',
     name: 'ServiceNow',
     enabled: true,
+    enabledInConfig: true,
+    enabledInLicense: true,
+    minimumLicenseRequired: 'platinum',
   },
 ];
 

x-pack/plugins/actions/common/types.ts

@@ -4,10 +4,15 @@
  * you may not use this file except in compliance with the Elastic License.
  */
 
+import { LicenseType } from '../../licensing/common/types';
+
 export interface ActionType {
   id: string;
   name: string;
   enabled: boolean;
+  enabledInConfig: boolean;
+  enabledInLicense: boolean;
+  minimumLicenseRequired: LicenseType;
 }
 
 export interface ActionResult {

x-pack/plugins/actions/server/action_type_registry.test.ts

@@ -132,6 +132,7 @@ describe('get()', () => {
 
 describe('list()', () => {
   test('returns list of action types', () => {
+    mockedLicenseState.isLicenseValidForActionType.mockReturnValue({ isValid: true });
     const actionTypeRegistry = new ActionTypeRegistry(actionTypeRegistryParams);
     actionTypeRegistry.register({
       id: 'my-action-type',
@@ -145,8 +146,13 @@ describe('list()', () => {
         id: 'my-action-type',
         name: 'My action type',
         enabled: true,
+        enabledInConfig: true,
+        enabledInLicense: true,
+        minimumLicenseRequired: 'basic',
       },
     ]);
+    expect(mockedActionsConfig.isActionTypeEnabled).toHaveBeenCalled();
+    expect(mockedLicenseState.isLicenseValidForActionType).toHaveBeenCalled();
   });
 });
 

x-pack/plugins/actions/server/action_type_registry.ts

@@ -117,7 +117,10 @@ export class ActionTypeRegistry {
     return Array.from(this.actionTypes).map(([actionTypeId, actionType]) => ({
       id: actionTypeId,
       name: actionType.name,
-      enabled: this.actionsConfigUtils.isActionTypeEnabled(actionTypeId),
+      minimumLicenseRequired: actionType.minimumLicenseRequired,
+      enabled: this.isActionTypeEnabled(actionTypeId),
+      enabledInConfig: this.actionsConfigUtils.isActionTypeEnabled(actionTypeId),
+      enabledInLicense: this.licenseState.isLicenseValidForActionType(actionType).isValid === true,
     }));
   }
 }

x-pack/plugins/triggers_actions_ui/public/application/lib/action_connector_api.test.ts

@@ -25,6 +25,9 @@ describe('loadActionTypes', () => {
         id: 'test',
         name: 'Test',
         enabled: true,
+        enabledInConfig: true,
+        enabledInLicense: true,
+        minimumLicenseRequired: 'basic',
       },
     ];
     http.get.mockResolvedValueOnce(resolvedValue);

x-pack/plugins/triggers_actions_ui/public/application/lib/action_type_compare.test.ts

@@ -0,0 +1,74 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { ActionType } from '../../types';
+import { actionTypeCompare } from './action_type_compare';
+
+test('should sort enabled action types first', async () => {
+  const actionTypes: ActionType[] = [
+    {
+      id: '1',
+      minimumLicenseRequired: 'basic',
+      name: 'first',
+      enabled: true,
+      enabledInConfig: true,
+      enabledInLicense: true,
+    },
+    {
+      id: '2',
+      minimumLicenseRequired: 'gold',
+      name: 'second',
+      enabled: false,
+      enabledInConfig: true,
+      enabledInLicense: false,
+    },
+    {
+      id: '3',
+      minimumLicenseRequired: 'basic',
+      name: 'third',
+      enabled: true,
+      enabledInConfig: true,
+      enabledInLicense: true,
+    },
+  ];
+  const result = [...actionTypes].sort(actionTypeCompare);
+  expect(result[0]).toEqual(actionTypes[0]);
+  expect(result[1]).toEqual(actionTypes[2]);
+  expect(result[2]).toEqual(actionTypes[1]);
+});
+
+test('should sort by name when all enabled', async () => {
+  const actionTypes: ActionType[] = [
+    {
+      id: '1',
+      minimumLicenseRequired: 'basic',
+      name: 'third',
+      enabled: true,
+      enabledInConfig: true,
+      enabledInLicense: true,
+    },
+    {
+      id: '2',
+      minimumLicenseRequired: 'basic',
+      name: 'first',
+      enabled: true,
+      enabledInConfig: true,
+      enabledInLicense: true,
+    },
+    {
+      id: '3',
+      minimumLicenseRequired: 'basic',
+      name: 'second',
+      enabled: true,
+      enabledInConfig: true,
+      enabledInLicense: true,
+    },
+  ];
+  const result = [...actionTypes].sort(actionTypeCompare);
+  expect(result[0]).toEqual(actionTypes[1]);
+  expect(result[1]).toEqual(actionTypes[2]);
+  expect(result[2]).toEqual(actionTypes[0]);
+});

x-pack/plugins/triggers_actions_ui/public/application/lib/action_type_compare.ts

@@ -0,0 +1,17 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { ActionType } from '../../types';
+
+export function actionTypeCompare(a: ActionType, b: ActionType) {
+  if (a.enabled === true && b.enabled === false) {
+    return -1;
+  }
+  if (a.enabled === false && b.enabled === true) {
+    return 1;
+  }
+  return a.name.localeCompare(b.name);
+}

x-pack/plugins/triggers_actions_ui/public/application/lib/check_action_type_enabled.scss

@@ -0,0 +1,9 @@
+.actCheckActionTypeEnabled__disabledActionWarningCard {
+  background-color: $euiColorLightestShade;
+}
+
+.actAccordionActionForm {
+  .euiCard {
+    box-shadow: none;
+  }
+}

x-pack/plugins/triggers_actions_ui/public/application/lib/check_action_type_enabled.test.tsx

@@ -0,0 +1,87 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import { ActionType } from '../../types';
+import { checkActionTypeEnabled } from './check_action_type_enabled';
+
+test(`returns isEnabled:true when action type isn't provided`, async () => {
+  expect(checkActionTypeEnabled()).toMatchInlineSnapshot(`
+    Object {
+      "isEnabled": true,
+    }
+  `);
+});
+
+test('returns isEnabled:true when action type is enabled', async () => {
+  const actionType: ActionType = {
+    id: '1',
+    minimumLicenseRequired: 'basic',
+    name: 'my action',
+    enabled: true,
+    enabledInConfig: true,
+    enabledInLicense: true,
+  };
+  expect(checkActionTypeEnabled(actionType)).toMatchInlineSnapshot(`
+    Object {
+      "isEnabled": true,
+    }
+  `);
+});
+
+test('returns isEnabled:false when action type is disabled by license', async () => {
+  const actionType: ActionType = {
+    id: '1',
+    minimumLicenseRequired: 'basic',
+    name: 'my action',
+    enabled: false,
+    enabledInConfig: true,
+    enabledInLicense: false,
+  };
+  expect(checkActionTypeEnabled(actionType)).toMatchInlineSnapshot(`
+    Object {
+      "isEnabled": false,
+      "message": "This connector is disabled because it requires a basic license.",
+      "messageCard": <EuiCard
+        className="actCheckActionTypeEnabled__disabledActionWarningCard"
+        description="To re-enable this action, please upgrade your license."
+        title="This feature requires a basic license."
+      >
+        <ForwardRef
+          href="https://www.elastic.co/subscriptions"
+          target="_blank"
+        >
+          <FormattedMessage
+            defaultMessage="View license options"
+            id="xpack.triggersActionsUI.sections.alertForm.actionTypeDisabledByLicenseLinkTitle"
+            values={Object {}}
+          />
+        </ForwardRef>
+      </EuiCard>,
+    }
+  `);
+});
+
+test('returns isEnabled:false when action type is disabled by config', async () => {
+  const actionType: ActionType = {
+    id: '1',
+    minimumLicenseRequired: 'basic',
+    name: 'my action',
+    enabled: false,
+    enabledInConfig: false,
+    enabledInLicense: true,
+  };
+  expect(checkActionTypeEnabled(actionType)).toMatchInlineSnapshot(`
+    Object {
+      "isEnabled": false,
+      "message": "This connector is disabled by the Kibana configuration.",
+      "messageCard": <EuiCard
+        className="actCheckActionTypeEnabled__disabledActionWarningCard"
+        description=""
+        title="This feature is disabled by the Kibana configuration."
+      />,
+    }
+  `);
+});

x-pack/plugins/triggers_actions_ui/public/application/lib/check_action_type_enabled.tsx

@@ -0,0 +1,93 @@
+/*
+ * Copyright Elasticsearch B.V. and/or licensed to Elasticsearch B.V. under one
+ * or more contributor license agreements. Licensed under the Elastic License;
+ * you may not use this file except in compliance with the Elastic License.
+ */
+
+import React from 'react';
+import { i18n } from '@kbn/i18n';
+import { FormattedMessage } from '@kbn/i18n/react';
+import { EuiCard, EuiLink } from '@elastic/eui';
+import { ActionType } from '../../types';
+import { VIEW_LICENSE_OPTIONS_LINK } from '../../common/constants';
+import './check_action_type_enabled.scss';
+
+export interface IsEnabledResult {
+  isEnabled: true;
+}
+export interface IsDisabledResult {
+  isEnabled: false;
+  message: string;
+  messageCard: JSX.Element;
+}
+
+export function checkActionTypeEnabled(
+  actionType?: ActionType
+): IsEnabledResult | IsDisabledResult {
+  if (actionType?.enabledInLicense === false) {
+    return {
+      isEnabled: false,
+      message: i18n.translate(
+        'xpack.triggersActionsUI.checkActionTypeEnabled.actionTypeDisabledByLicenseMessage',
+        {
+          defaultMessage:
+            'This connector is disabled because it requires a {minimumLicenseRequired} license.',
+          values: {
+            minimumLicenseRequired: actionType.minimumLicenseRequired,
+          },
+        }
+      ),
+      messageCard: (
+        <EuiCard
+          titleSize="xs"
+          title={i18n.translate(
+            'xpack.triggersActionsUI.sections.alertForm.actionTypeDisabledByLicenseMessageTitle',
+            {
+              defaultMessage: 'This feature requires a {minimumLicenseRequired} license.',
+              values: {
+                minimumLicenseRequired: actionType.minimumLicenseRequired,
+              },
+            }
+          )}
+          // The "re-enable" terminology is used here because this message is used when an alert
+          // action was previously enabled and needs action to be re-enabled.
+          description={i18n.translate(
+            'xpack.triggersActionsUI.sections.alertForm.actionTypeDisabledByLicenseMessageDescription',
+            { defaultMessage: 'To re-enable this action, please upgrade your license.' }
+          )}
+          className="actCheckActionTypeEnabled__disabledActionWarningCard"
+          children={
+            <EuiLink href={VIEW_LICENSE_OPTIONS_LINK} target="_blank">
+              <FormattedMessage
+                defaultMessage="View license options"
+                id="xpack.triggersActionsUI.sections.alertForm.actionTypeDisabledByLicenseLinkTitle"
+              />
+            </EuiLink>
+          }
+        />
+      ),
+    };
+  }
+
+  if (actionType?.enabledInConfig === false) {
+    return {
+      isEnabled: false,
+      message: i18n.translate(
+        'xpack.triggersActionsUI.checkActionTypeEnabled.actionTypeDisabledByConfigMessage',
+        { defaultMessage: 'This connector is disabled by the Kibana configuration.' }
+      ),
+      messageCard: (
+        <EuiCard
+          title={i18n.translate(
+            'xpack.triggersActionsUI.sections.alertForm.actionTypeDisabledByConfigMessageTitle',
+            { defaultMessage: 'This feature is disabled by the Kibana configuration.' }
+          )}
+          description=""
+          className="actCheckActionTypeEnabled__disabledActionWarningCard"
+        />
+      ),
+    };
+  }
+
+  return { isEnabled: true };
+}