@atlaskit/rovo-agent-components/dist/esm/ui/agent-verification-dropdown-item/index.js

This package host public components related to rovo agents, the components here are needed for other public atlaskit packages

import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
import _agentVerificationDropdownItem_AtlaskitRovoAgentComponents_updateAgentVerificationMutation from "./__generated__/agentVerificationDropdownItem_AtlaskitRovoAgentComponents_updateAgentVerificationMutation.graphql";
import _agentVerificationDropdownItem_AtlaskitRovoAgentComponents_userPermissionsRef from "./__generated__/agentVerificationDropdownItem_AtlaskitRovoAgentComponents_userPermissionsRef.graphql";
import _agentVerificationDropdownItem_AtlaskitRovoAgentComponents_agentRef from "./__generated__/agentVerificationDropdownItem_AtlaskitRovoAgentComponents_agentRef.graphql";
import React, { useCallback } from 'react';
import { useIntl } from 'react-intl';
import { graphql, useFragment, useMutation } from 'react-relay';
import { DropdownItem } from '@atlaskit/dropdown-menu';
import { useFlags } from '@atlaskit/flag';
import ErrorIcon from '@atlaskit/icon/core/status-error';
import SuccessIcon from '@atlaskit/icon/core/status-success';
import { useRovoAgentActionAnalytics } from '@atlaskit/rovo-agent-analytics/actions';
import messages from './messages';
/**
 * A dropdown item for verifying or unverifying an agent.
 * Renders "Verify agent" if the agent is not verified, or "Remove verification" if it is.
 * Returns null if the user doesn't have permission to govern agents or the feature flag is off.
 */
export var AgentVerificationDropdownItem = function AgentVerificationDropdownItem(_ref) {
  var _userPermissions$isAb, _agentData$isVerified;
  var agentRef = _ref.agentRef,
    userPermissionsRef = _ref.userPermissionsRef,
    onClick = _ref.onClick,
    onVerificationSuccess = _ref.onVerificationSuccess,
    testId = _ref.testId,
    renderItem = _ref.renderItem;
  var _useIntl = useIntl(),
    formatMessage = _useIntl.formatMessage;
  var _useFlags = useFlags(),
    showFlag = _useFlags.showFlag;
  var agentData = useFragment(_agentVerificationDropdownItem_AtlaskitRovoAgentComponents_agentRef, agentRef);
  var userPermissions = useFragment(_agentVerificationDropdownItem_AtlaskitRovoAgentComponents_userPermissionsRef, userPermissionsRef);
  var isAbleToGovernAgents = (_userPermissions$isAb = userPermissions === null || userPermissions === void 0 ? void 0 : userPermissions.isAbleToGovernAgents) !== null && _userPermissions$isAb !== void 0 ? _userPermissions$isAb : false;
  var isVerified = (_agentData$isVerified = agentData === null || agentData === void 0 ? void 0 : agentData.isVerified) !== null && _agentData$isVerified !== void 0 ? _agentData$isVerified : false;
  var agentId = agentData === null || agentData === void 0 ? void 0 : agentData.id;
  var _useRovoAgentActionAn = useRovoAgentActionAnalytics({
      touchPoint: 'agent-verification-dropdown-item',
      agentId: agentId,
      isAbleToGovernAgents: isAbleToGovernAgents
    }),
    trackAgentEvent = _useRovoAgentActionAn.trackAgentEvent;
  var _useMutation = useMutation(_agentVerificationDropdownItem_AtlaskitRovoAgentComponents_updateAgentVerificationMutation),
    _useMutation2 = _slicedToArray(_useMutation, 2),
    commitUpdateVerification = _useMutation2[0],
    isPending = _useMutation2[1];
  var handleError = useCallback(function (verified, errorMessage) {
    showFlag({
      title: formatMessage(verified ? messages.verifyErrorTitle : messages.unverifyErrorTitle),
      description: formatMessage(messages.errorDescription, {
        errorMessage: errorMessage
      }),
      appearance: 'error',
      icon: /*#__PURE__*/React.createElement(ErrorIcon, {
        spacing: "spacious",
        label: ""
      })
    });
  }, [formatMessage, showFlag]);
  var handleUpdateVerification = useCallback(function (verified) {
    if (!agentId) {
      return;
    }
    onClick === null || onClick === void 0 || onClick();
    commitUpdateVerification({
      variables: {
        id: agentId,
        verified: verified
      },
      onCompleted: function onCompleted(response) {
        var payload = response === null || response === void 0 ? void 0 : response.agentStudio_updateAgentVerification;
        if (payload !== null && payload !== void 0 && payload.success) {
          onVerificationSuccess === null || onVerificationSuccess === void 0 || onVerificationSuccess(verified);
          trackAgentEvent({
            action: verified ? 'verify' : 'unverify',
            actionSubject: 'rovoAgent',
            attributes: {}
          });
          showFlag({
            title: formatMessage(verified ? messages.verifySuccessTitle : messages.unverifySuccessTitle),
            appearance: 'success',
            isAutoDismiss: true,
            icon: /*#__PURE__*/React.createElement(SuccessIcon, {
              spacing: "spacious",
              label: ""
            })
          });
        } else {
          var _payload$errors;
          var errorMessage = payload === null || payload === void 0 || (_payload$errors = payload.errors) === null || _payload$errors === void 0 || (_payload$errors = _payload$errors[0]) === null || _payload$errors === void 0 ? void 0 : _payload$errors.message;
          if (errorMessage) {
            trackAgentEvent({
              action: verified ? 'verify' : 'unverify',
              actionSubject: 'rovoAgentError',
              attributes: {
                agentId: agentId,
                error: {
                  message: errorMessage
                }
              }
            });
            handleError(verified, errorMessage);
          }
        }
      },
      onError: function onError(error) {
        trackAgentEvent({
          action: verified ? 'verify' : 'unverify',
          actionSubject: 'rovoAgentError',
          attributes: {
            agentId: agentId,
            error: {
              message: error.message
            }
          }
        });
        handleError(verified, error.message);
      }
    });
  }, [agentId, commitUpdateVerification, formatMessage, handleError, onClick, onVerificationSuccess, showFlag, trackAgentEvent]);
  var labelText = formatMessage(isVerified ? messages.unverifyAgentLabel : messages.verifyAgentLabel);
  var handleOnClick = function handleOnClick() {
    return handleUpdateVerification(!isVerified);
  };
  if (
  // Don't render if agent ID is not available
  !agentId ||
  // Don't render if user doesn't have permission
  !isAbleToGovernAgents) {
    return null;
  }

  // Use custom render or default to DropdownItem
  if (renderItem) {
    return /*#__PURE__*/React.createElement(React.Fragment, null, renderItem({
      isPending: isPending,
      isVerified: isVerified,
      labelText: labelText,
      onClick: handleOnClick
    }));
  }
  return /*#__PURE__*/React.createElement(DropdownItem, {
    testId: testId,
    onClick: handleOnClick
  }, labelText);
};