Fix: whatsapp actions with notification

Author: saimanoj

actions/whatsapp/config.json

@@ -14,7 +14,7 @@
     },
     {
       "type": "on_update",
-      "entities": ["LinkedIssue"]
+      "entities": ["Issue"]
     }
   ],
   "integrations": ["whatsapp"]

actions/whatsapp/handlers/on-update-handler.ts

@@ -0,0 +1,15 @@
+import { ActionEventPayload, ModelNameEnum, logger } from '@tegonhq/sdk';
+import { issueSync } from 'triggers/update-issue';
+
+export const onUpdateHandler = async (actionPayload: ActionEventPayload) => {
+  // Handle different event types
+  switch (actionPayload.type) {
+    case ModelNameEnum.Issue:
+      return await issueSync(actionPayload);
+
+    default:
+      logger.debug('Unhandled Whatsapp event type:', actionPayload.type);
+  }
+
+  return { status: 200 };
+};

actions/whatsapp/index.ts

@@ -3,6 +3,7 @@ import { ActionEventPayload, ActionTypesEnum } from '@tegonhq/sdk';
 import { webhookHandler } from './handlers/webhook-handler';
 import { getInputs } from 'handlers/get-inputs';
 import { onCreateHandler } from 'handlers/on-create-handler';
+import { onUpdateHandler } from 'handlers/on-update-handler';
 
 export async function run(eventPayload: ActionEventPayload) {
   switch (eventPayload.event) {
@@ -15,6 +16,9 @@ export async function run(eventPayload: ActionEventPayload) {
     case ActionTypesEnum.ON_CREATE:
       return await onCreateHandler(eventPayload);
 
+    case ActionTypesEnum.ON_UPDATE:
+      return onUpdateHandler(eventPayload);
+
     default:
       return {
         message: `The event payload type "${eventPayload.event}" is not recognized`,

actions/whatsapp/triggers/comment-sync.ts

@@ -27,7 +27,6 @@ export const commentSync = async (actionPayload: ActionEventPayload) => {
   }
 
   const parentIssueComment = issueComment.parent;
-
   const parentSourceMetadata = parentIssueComment
     ? // eslint-disable-next-line @typescript-eslint/no-explicit-any
       (parentIssueComment.sourceMetadata as Record<string, any>)
@@ -59,7 +58,7 @@ export const commentSync = async (actionPayload: ActionEventPayload) => {
   }
 
   // Send a POST request to the Slack API to post the message
-  await axios.post('http://localhost:3002/messages/broadcast', {
+  await axios.post(`${process.env.SOCKET_SERVER_URL}/messages/broadcast`, {
     clientId: integrationAccount.accountId,
     payload: {
       type: 'ISSUE_COMMENT',

actions/whatsapp/triggers/triage.ts

@@ -22,8 +22,12 @@ export const whatsappTriage = async (
     body,
     messageId: { _serialized: sourceId },
     messageId,
-    chat: { name: username, id: chatId },
+    chat: { name: chatName, id: chatId },
     from,
+    user: {
+      id: { _serialized: whatsappUserId },
+      name: username,
+    },
   } = eventBody;
 
   // Skip status messages from WhatsApp
@@ -131,15 +135,15 @@ export const whatsappTriage = async (
     whatsappUsername,
   );
   const supportData = {
-    email: chatId._serialized,
+    email: whatsappUserId,
     name: username,
     source: 'Whatsapp',
     companyId,
   };
 
   const createdIssue = await createIssue({ ...issueInput, supportData });
 
-  await axios.post('http://localhost:3002/messages/broadcast', {
+  await axios.post(`${process.env.SOCKET_SERVER_URL}/messages/broadcast`, {
     clientId: integrationAccount.accountId,
     payload: {
       type: 'ISSUE_CREATED',
@@ -151,7 +155,7 @@ export const whatsappTriage = async (
   // Create Link Comment
   const issueComment = await createIssueComment({
     issueId: createdIssue.id,
-    body: `Whatsapp conversation in #${whatsappUsername}`,
+    body: `Whatsapp conversation in #${chatName}`,
     sourceMetadata: { ...sourceMetadata, synced: true },
   });
 

actions/whatsapp/triggers/update-issue.ts

@@ -0,0 +1,69 @@
+import {
+  ActionEventPayload,
+  getIssueById,
+  getLinkedIssuesByIssueId,
+  getWorkflowsByTeam,
+  JsonObject,
+} from '@tegonhq/sdk';
+import axios from 'axios';
+
+export const issueSync = async (actionPayload: ActionEventPayload) => {
+  const { changedData } = actionPayload;
+
+  if (!changedData.stateId) {
+    return {
+      message: 'No state change detected',
+    };
+  }
+
+  const integrationAccount = actionPayload.integrationAccounts.whatsapp;
+
+  const issue = await getIssueById({ issueId: actionPayload.modelId });
+
+  const workflows = await getWorkflowsByTeam({ teamId: issue.teamId });
+
+  const workflowState = workflows.find(
+    (workflow) => workflow.id === changedData.stateId,
+  );
+
+  if (!workflowState) {
+    return {
+      message: 'Workflow state not found',
+    };
+  }
+
+  const isDone = workflowState.category === 'COMPLETED';
+
+  if (isDone) {
+    const message = `This ticket #${issue.number} is closed`;
+    const linkedIssues = await getLinkedIssuesByIssueId({ issueId: issue.id });
+
+    linkedIssues.map(async (linkedIssue) => {
+      const sourceData = linkedIssue.sourceData as JsonObject;
+      const clientId = integrationAccount.accountId;
+      const chatId = sourceData.chatId as JsonObject;
+
+      if (sourceData.type === integrationAccount.integrationDefinition.slug) {
+        await axios.post(
+          `${process.env.SOCKET_SERVER_URL}/messages/broadcast`,
+          {
+            clientId,
+            payload: {
+              chatId: chatId._serialized,
+              message,
+            },
+          },
+          {
+            headers: {
+              'Content-Type': 'application/json',
+            },
+          },
+        );
+      }
+    });
+  }
+
+  return {
+    message: `Issue state is ${isDone ? 'completed' : 'not completed'}`,
+  };
+};

actions/whatsapp/utils.ts

@@ -92,7 +92,7 @@ export async function isCreateTicket(
         ),
       },
     ],
-    llmModel: LLMMappings.GPT35TURBO,
+    llmModel: LLMMappings.GPT4O,
     model: 'GroupCompanyName',
     workspaceId,
   };

apps/server/package.json

@@ -123,6 +123,7 @@
     "rxjs": "7.8.1",
     "simple-oauth2": "^5.0.0",
     "socket.io": "^4.7.5",
+    "socket.io-client": "^4.7.4",
     "supertokens-node": "^21.0.0",
     "turndown": "^7.2.0",
     "typesense": "^1.7.2",

apps/server/src/integrations/whatsapp-business/account-create.ts

@@ -0,0 +1,60 @@
+import { PrismaClient } from '@prisma/client';
+import axios from 'axios';
+import { createIntegrationAccount } from 'integrations/utils';
+
+const prisma = new PrismaClient();
+
+export const integrationCreate = async (
+  userId: string,
+  workspaceId: string,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  data: any,
+) => {
+  const { oauthResponse, personal, integrationDefinition, oauthParams } = data;
+  const integrationConfiguration = {
+    access_token: oauthResponse.access_token,
+    access_expires_in: oauthResponse.expires_at,
+  };
+
+  console.log(oauthResponse, oauthParams);
+  const appData = await axios.get(
+    `https://graph.facebook.com/v22.0/debug_token?input_token=${oauthParams.code}`,
+  );
+
+  const businessManagementScope = appData.data.data.granular_scopes.find(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    (scope: any) => scope.scope === 'whatsapp_business_management',
+  );
+
+  console.log(businessManagementScope);
+  const accountId = businessManagementScope?.target_ids[0];
+
+  if (!accountId) {
+    throw new Error('No WhatsApp Business Account ID found');
+  }
+
+  // Subscribe the app to the WhatsApp Business Account
+  await axios.post(
+    `https://graph.facebook.com/v22.0/${accountId}/subscribed_apps`,
+    {},
+    {
+      headers: {
+        Authorization: `Bearer ${integrationConfiguration.access_token}`,
+      },
+    },
+  );
+
+  // Update the integration account with the new configuration in the database
+  const integrationAccount = await createIntegrationAccount(prisma, {
+    userId,
+    accountId,
+    config: integrationConfiguration,
+    workspaceId,
+    integrationDefinitionId: integrationDefinition.id,
+    personal,
+  });
+
+  return {
+    message: `Created integration account ${integrationAccount.id}`,
+  };
+};

apps/server/src/integrations/whatsapp-business/index.ts

@@ -0,0 +1,43 @@
+import {
+  IntegrationEventPayload,
+  IntegrationPayloadEventType,
+} from '@tegonhq/types';
+
+import { integrationCreate } from './account-create';
+import { spec } from './spec';
+import { webhookResponse } from './webhook-response';
+
+export default async function run(eventPayload: IntegrationEventPayload) {
+  switch (eventPayload.event) {
+    /**
+     * This is used to identify to which integration account the webhook belongs to
+     */
+    case IntegrationPayloadEventType.GET_CONNECTED_ACCOUNT_ID:
+      return eventPayload.data.eventBody.accountId;
+
+    case IntegrationPayloadEventType.SPEC:
+      return spec();
+
+    case IntegrationPayloadEventType.IS_ACTION_SUPPORTED_EVENT:
+      return true;
+
+    // Used to save settings data
+    case IntegrationPayloadEventType.CREATE:
+      return await integrationCreate(
+        eventPayload.userId,
+        eventPayload.workspaceId,
+        eventPayload.data,
+      );
+
+    case IntegrationPayloadEventType.WEBHOOK_RESPONSE:
+      return await webhookResponse(
+        eventPayload.eventQueryParams,
+        eventPayload.eventBody,
+      );
+
+    default:
+      return {
+        message: `The event payload type is ${eventPayload.event}`,
+      };
+  }
+}