feat(slack/onboard-llmo): add IMS org onboarding option

Author: cwjwisse

package-lock.json

@@ -80,6 +80,7 @@ export function initSlackBot(lambdaContext, App) {
   app.view('onboard_site_modal', actions.onboardSiteModal(lambdaContext));
   app.view('preflight_config_modal', actions.preflight_config_modal(lambdaContext));
   app.view('onboard_llmo_modal', actions.onboardLLMOModal(lambdaContext));
+  app.view('onboard_llmo_org_modal', actions.onboardLLMOOrgModal(lambdaContext));
   app.view('update_ims_org_modal', actions.updateIMSOrgModal(lambdaContext));
 
   return app;

src/controllers/slack.js

@@ -21,6 +21,8 @@ import {
   addEntitlementsAction,
   updateOrgAction,
   updateIMSOrgModal,
+  startLLMOOrgOnboarding,
+  onboardLLMOOrgModal,
 } from './onboard-llmo-modal.js';
 import { onboardSiteModal, startOnboarding } from './onboard-modal.js';
 import { preflightConfigModal } from './preflight-config-modal.js';
@@ -34,9 +36,11 @@ const actions = {
   rejectOrg,
   onboardSiteModal,
   onboardLLMOModal,
+  onboardLLMOOrgModal,
   updateIMSOrgModal,
   start_onboarding: startOnboarding,
   start_llmo_onboarding: startLLMOOnboarding,
+  start_llmo_org_onboarding: startLLMOOrgOnboarding,
   preflight_config_modal: preflightConfigModal,
   open_preflight_config: openPreflightConfig,
   add_entitlements_action: addEntitlementsAction,

src/support/slack/actions/index.js

@@ -940,3 +940,197 @@ export function updateIMSOrgModal(lambdaContext) {
     }
   };
 }
+
+/* Handles "Start Onboarding" button click for IMS org onboarding */
+export function startLLMOOrgOnboarding(lambdaContext) {
+  const { log } = lambdaContext;
+
+  return async ({
+    ack, body, client, respond,
+  }) => {
+    try {
+      await ack();
+
+      const { user } = body;
+
+      await respond({
+        text: `:gear: ${user.name} started the IMS org onboarding process...`,
+        replace_original: true,
+      });
+
+      const originalChannel = body.channel?.id;
+      const originalThreadTs = body.message?.thread_ts || body.message?.ts;
+
+      await client.views.open({
+        trigger_id: body.trigger_id,
+        view: {
+          type: 'modal',
+          callback_id: 'onboard_llmo_org_modal',
+          private_metadata: JSON.stringify({
+            originalChannel,
+            originalThreadTs,
+          }),
+          title: {
+            type: 'plain_text',
+            text: 'Onboard IMS Org',
+          },
+          submit: {
+            type: 'plain_text',
+            text: 'Start Onboarding',
+          },
+          close: {
+            type: 'plain_text',
+            text: 'Cancel',
+          },
+          blocks: [
+            {
+              type: 'section',
+              text: {
+                type: 'mrkdwn',
+                text: ':rocket: *LLMO IMS Org Onboarding*\n\nProvide the IMS Organization ID to onboard for LLMO.',
+              },
+            },
+            {
+              type: 'input',
+              block_id: 'ims_org_input',
+              element: {
+                type: 'plain_text_input',
+                action_id: 'ims_org_id',
+                placeholder: {
+                  type: 'plain_text',
+                  text: 'ABC123@AdobeOrg',
+                },
+              },
+              label: {
+                type: 'plain_text',
+                text: 'IMS Organization ID',
+              },
+            },
+          ],
+        },
+      });
+
+      log.debug(`User ${user.id} started IMS org onboarding process.`);
+    } catch (error) {
+      log.error('Error starting IMS org onboarding:', error);
+      await postErrorMessage(respond, error);
+    }
+  };
+}
+
+/* Handles IMS org onboarding modal submission */
+export function onboardLLMOOrgModal(lambdaContext) {
+  const { log, dataAccess, imsClient } = lambdaContext;
+
+  return async ({ ack, body, client }) => {
+    try {
+      const { user, view } = body;
+      const { values } = view.state;
+
+      const imsOrgId = values.ims_org_input?.ims_org_id?.value?.trim();
+      const metadata = JSON.parse(view.private_metadata || '{}');
+      const { originalChannel, originalThreadTs } = metadata;
+
+      if (!imsOrgId) {
+        await ack({
+          response_action: 'errors',
+          errors: {
+            ims_org_input: 'IMS Organization ID is required',
+          },
+        });
+        return;
+      }
+
+      await ack();
+      const responseChannel = originalChannel || body.user.id;
+      const responseThreadTs = originalChannel ? originalThreadTs : undefined;
+
+      const slackContext = {
+        say: async (message) => {
+          await client.chat.postMessage({
+            channel: responseChannel,
+            text: message,
+            thread_ts: responseThreadTs,
+          });
+        },
+        client,
+        channelId: responseChannel,
+        threadTs: responseThreadTs,
+      };
+
+      await slackContext.say(`:gear: Starting LLMO IMS org onboarding for *${imsOrgId}*...`);
+
+      // Create or find organization
+      const { Organization } = dataAccess;
+      let organization = await Organization.findByImsOrgId(imsOrgId);
+
+      if (!organization) {
+        log.info(`Creating new organization for IMS Org ID: ${imsOrgId}`);
+        await slackContext.say(`Creating organization for IMS Org ID: ${imsOrgId}`);
+
+        // Fetch IMS org details
+        let imsOrgDetails;
+        try {
+          imsOrgDetails = await imsClient.getImsOrganizationDetails(imsOrgId);
+        } catch (error) {
+          log.error(`Error retrieving IMS Org details: ${error.message}`);
+          await slackContext.say(`:x: Could not find an IMS org with the ID *${imsOrgId}*.`);
+          return;
+        }
+
+        if (!imsOrgDetails) {
+          await slackContext.say(`:x: Could not find an IMS org with the ID *${imsOrgId}*.`);
+          return;
+        }
+
+        organization = await Organization.create({
+          name: imsOrgDetails.orgName,
+          imsOrgId,
+        });
+        await organization.save();
+        log.info(`Created organization ${organization.getId()} for IMS Org ID: ${imsOrgId}`);
+      } else {
+        log.info(`Found existing organization ${organization.getId()} for IMS Org ID: ${imsOrgId}`);
+        await slackContext.say(`Found existing organization for IMS Org ID: ${imsOrgId}`);
+      }
+
+      try {
+        const tierClient = TierClient.createForOrg(lambdaContext, organization, LLMO_PRODUCT_CODE);
+        const { entitlement: existingEntitlement } = await tierClient.checkValidEntitlement();
+        const { entitlement } = await tierClient.createEntitlement(LLMO_TIER);
+        const wasNewlyCreated = !existingEntitlement
+          || existingEntitlement.getId() !== entitlement.getId();
+
+        if (wasNewlyCreated) {
+          log.info(`Successfully created LLMO entitlement ${entitlement.getId()} for organization ${organization.getId()}`);
+        } else {
+          log.info(`Found existing LLMO entitlement ${entitlement.getId()} for organization ${organization.getId()}`);
+        }
+
+        await slackContext.say(`:white_check_mark: *LLMO IMS org onboarding completed successfully!*
+
+*Organization:* ${organization.getName()}
+*IMS Org ID:* ${imsOrgId}
+*Entitlement ID:* ${entitlement.getId()}
+*Tier:* ${LLMO_TIER}
+*Status:* ${wasNewlyCreated ? 'New entitlement created' : 'Existing entitlement found and verified'}
+
+The organization has been onboarded for LLMO.`);
+      } catch (error) {
+        log.error(`Error creating entitlement for organization: ${error.message}`);
+        await slackContext.say(`:x: Failed to create LLMO entitlement for organization: ${error.message}`);
+        return;
+      }
+
+      log.debug(`IMS org onboarding completed for ${imsOrgId} by user ${user.id}`);
+    } catch (error) {
+      log.error('Error handling IMS org onboarding modal:', error);
+      await ack({
+        response_action: 'errors',
+        errors: {
+          ims_org_input: 'There was an error processing the onboarding request.',
+        },
+      });
+    }
+  };
+}

src/support/slack/actions/onboard-llmo-modal.js

@@ -30,9 +30,9 @@ function LlmoOnboardCommand(context) {
   const baseCommand = BaseCommand({
     id: 'onboard-llmo',
     name: 'Onboard LLMO',
-    description: 'Onboards a site for LLMO (Large Language Model Optimizer) through a modal interface.',
+    description: 'Onboards a site or IMS org for LLMO (Large Language Model Optimizer) through a modal interface.',
     phrases: PHRASES,
-    usageText: `${PHRASES[0]} <site url>`,
+    usageText: `${PHRASES[0]} [site url]`,
   });
 
   const { log } = context;
@@ -51,6 +51,39 @@ function LlmoOnboardCommand(context) {
 
     const [site] = args;
 
+    // If no site parameter provided, trigger IMS org onboarding flow
+    if (!site) {
+      const message = {
+        blocks: [
+          {
+            type: 'section',
+            text: {
+              type: 'mrkdwn',
+              text: ':rocket: *LLMO IMS Org Onboarding*\n\nClick the button below to start the IMS organization onboarding process.',
+            },
+          },
+          {
+            type: 'actions',
+            elements: [
+              {
+                type: 'button',
+                text: {
+                  type: 'plain_text',
+                  text: 'Start Onboarding',
+                },
+                value: 'org_onboarding',
+                action_id: 'start_llmo_org_onboarding',
+                style: 'primary',
+              },
+            ],
+          },
+        ],
+        thread_ts: threadTs,
+      };
+      await say(message);
+      return;
+    }
+
     const normalizedSite = extractURLFromSlackInput(site);
 
     if (!normalizedSite) {