Comment events

app.post("/webhook/platform-events", async (req, res) => {
  const event = req.body;
  if (!event?.eventId || !event?.eventType?.includes(":comment:")) {
    return res.status(200).send("OK");
  }
  res.status(200).send("OK");

  switch (event.eventType) {
    case "ticket:comment:created":
      await onTicketCommentCreated(event.payload);
      break;
    case "account-task:comment:updated":
      await onAccountTaskCommentUpdated(event.payload);
      break;
    default:
      break;
  }
});

interface CommentEventPayload {
  comment: {
    id: string;
    content?: string; // May be omitted for certain visibility rules
    contentHtml?: string;
    contentMarkdown?: string;
    contentJson?: string;
    commentType: string;
    parentCommentId?: string;
    teamId?: string; // For ticket comments
    accountId?: string; // For account-related comments
    metadata: Record<string, unknown>;
    customerContact?: {
      id: string;
      email: string;
      avatarUrl: string;
    };
    author: {
      id: string;
      name: string;
      email: string;
      avatarUrl: string;
    };
    attachments: Array<{
      id: string;
      name: string;
      url: string;
      size: number;
      contentType: string;
      createdAt: Date;
      updatedAt: Date;
      deletedAt?: Date;
    }>;
    commentVisibility: string;
    createdAt: Date;
    updatedAt: Date;
    deletedAt?: Date;
    shouldSendEmail?: boolean; // Only for created events
    createdWithTicket?: boolean; // Only for created events
  };
  // Entity-specific payload additions
  ticket?: {
    id: string;
    title: string;
    description?: string;
    requestorEmail?: string;
    submitterEmail?: string;
    source: string;
    isProactive?: boolean;
    proactiveChannels?: string[];
  };
  accountTask?: {
    id: string;
    title: string;
  };
  accountActivity?: {
    id: string;
  };
  accountNote?: {
    id: string;
  };
}

interface CommentUpdateEventPayload {
  comment: {
    previous: CommentData; // Previous state of the comment
    updated: CommentData; // Updated state of the comment
  };
  // Same entity-specific additions as above
}

interface ReactionEventPayload {
  reaction: {
    name: string; // Emoji name (e.g., "thumbs_up", "heart")
    author: {
      id: string;
      name: string;
      avatarUrl: string;
      email: string;
    };
    metadata: Record<string, any>;
  };
  comment: {
    id: string;
  };
}

interface CommentEventEnvelope {
  eventId: string;
  eventType: string; // e.g., "ticket:comment:created"
  timestamp: string;
  orgId: string;
  actor: {
    id: string;
    type: string;
    email: string;
  };
  payload:
    | CommentEventPayload
    | CommentUpdateEventPayload
    | ReactionEventPayload;
}

{
  mentions: {
    users: Array<{
      id: string;
      email: string;
      name: string;
    }>;
  }
  ignoreSelf: boolean; // Indicates if the author should be excluded from notifications
}

{
  source: "slack" | "email" | "api" | "web";
  integrationId?: string;
  externalId?: string;
  syncStatus?: string;
}

function handleCommentCreated(payload) {
  const { comment, ticket, accountTask } = payload;

  // Determine notification recipients
  const recipients = [];

  if (ticket) {
    // Notify ticket participants
    recipients.push(ticket.assignedAgent);
    recipients.push(ticket.customer);
  } else if (accountTask) {
    // Notify task assignee and watchers
    recipients.push(accountTask.assignedUser);
    recipients.push(...accountTask.watchers);
  }

  // Send notifications
  recipients.forEach((recipient) => {
    if (comment.shouldSendEmail) {
      sendEmailNotification(recipient, comment, { ticket, accountTask });
    }
    sendInAppNotification(recipient, comment);
  });
}

function handleCommentUpdate(payload) {
  const { comment } = payload;
  const { previous, updated } = comment;

  // Sync to external systems
  if (previous.content !== updated.content) {
    // Content changed
    syncContentToExternalSystems(updated);

    // Log edit history
    logCommentEdit({
      commentId: updated.id,
      previousContent: previous.content,
      newContent: updated.content,
      editedBy: payload.actor.id,
      editedAt: updated.updatedAt,
    });
  }

  // Update search index
  updateSearchIndex(updated);
}

function handleReactionEvent(payload) {
  const { reaction, comment } = payload;

  // Update reaction counts
  updateReactionCounts(comment.id, reaction.name, payload.eventType);

  // Notify comment author (if not self-reaction)
  if (reaction.author.id !== comment.author.id) {
    notifyCommentAuthor(comment.author.id, {
      type: "reaction",
      reaction: reaction.name,
      reactorName: reaction.author.name,
      commentId: comment.id,
    });
  }

  // Track engagement metrics
  trackEngagement({
    type: "reaction",
    reactionType: reaction.name,
    commentId: comment.id,
    userId: reaction.author.id,
  });
}

function handleCommentWithMentions(payload) {
  const { comment, metadata } = payload;

  if (metadata?.mentions?.users) {
    metadata.mentions.users.forEach((mentionedUser) => {
      // Skip self-mentions if ignoreSelf is true
      if (metadata.ignoreSelf && mentionedUser.id === comment.author.id) {
        return;
      }

      // Send mention notification
      sendMentionNotification(mentionedUser, {
        comment,
        mentionedBy: comment.author,
        context:
          payload.ticket || payload.accountTask || payload.accountActivity,
      });

      // Track mention metrics
      trackMention({
        mentionedUserId: mentionedUser.id,
        mentionedByUserId: comment.author.id,
        commentId: comment.id,
      });
    });
  }
}

function handleThreadedComment(payload) {
  const { comment } = payload;

  if (comment.parentCommentId) {
    // This is a reply to another comment
    const parentComment = getCommentById(comment.parentCommentId);

    // Notify parent comment author
    notifyCommentAuthor(parentComment.author.id, {
      type: "reply",
      replyId: comment.id,
      replyContent: comment.content,
      repliedBy: comment.author,
    });

    // Update thread metrics
    updateThreadMetrics(comment.parentCommentId);
  }
}

function handleCommentAttachments(payload) {
  const { comment } = payload;

  comment.attachments?.forEach((attachment) => {
    // Process attachment
    processAttachment({
      id: attachment.id,
      name: attachment.name,
      size: attachment.size,
      contentType: attachment.contentType,
      url: attachment.url,
      commentId: comment.id,
    });

    // Virus scan for new attachments
    if (payload.eventType.includes("created")) {
      scheduleVirusScan(attachment.id);
    }

    // Update storage metrics
    updateStorageMetrics(attachment.size);
  });
}