CrossTalkPM/src/workflows/WorkflowOrchestrator.ts

import { CommentParser } from "../rdrama/services/CommentParser";
import { CommentPoster } from "../rdrama/services/CommentPoster";
import { MessageFileName, MessageService } from "../utils/MessageService";
import { DatabaseService } from "../db/services/Database";
import { RedditService } from "../reddit/services/Reddit";
import { shouldNotifyUser } from "../utils/ShouldNotify";
import { Comment } from "../rdrama/models/Comment";

class WorkflowOrchestrator {

    /**
     * Executes the defined workflow for processing comments.
     */
    async executeWorkflow(comment: Comment) {
        try {
            const canSend = await DatabaseService.canSendNotification();
            const coolDownHours = process.env.NOTIFICATION_COOLDOWN_HOURS
            if (!canSend) {
                console.log(`Last Message Sent less than ${coolDownHours ? coolDownHours : 4} hours ago. Set NOTIFICATION_COOLDOWN_HOURS to change this`)
                return;
            }
            await this.processComment(comment);
        } catch (error) {
            console.error('An error occurred during workflow execution:', error);
        }
    }

    /**
     * Processes a single comment, including posting responses and sending notifications.
     * @param {Object} comment The comment to process.
     */
    async processComment(comment: Comment) {
        const redditUsers = CommentParser.extractUsernames(comment);
        if (redditUsers.length === 0) return;
        console.log('found:', redditUsers);

        await this.postCommentAndNotify(comment, redditUsers[0]);
    }

    /**
     * Posts a comment response and sends a notification if the user should be notified.
     * @param {Object} comment The original comment.
     * @param {string} redditUser The Reddit user to notify.
     */
    async postCommentAndNotify(comment: Comment, redditUser: string) {
        const placeholdersRdrama = { author_name: comment.author_name };

        const userMentionExists = await DatabaseService.userMentionExists(redditUser);
        if (userMentionExists) {
            const commentPreviouslyMessaged = MessageService.getRandomMessage(MessageFileName.RdramaPreviousMessage, placeholdersRdrama);
            if (!commentPreviouslyMessaged) throw new Error('No comments for previous Message found');
            const postedComment = await CommentPoster.postComment(`c_${comment.id}`, `${commentPreviouslyMessaged}`);
            console.log(`Sent Comment to`, JSON.stringify(postedComment, null, 4));
            return;
        }
        const resultshouldNotifyUser = await shouldNotifyUser(redditUser);
        if (!resultshouldNotifyUser) {
            const commentShouldntNotify = MessageService.getRandomMessage(MessageFileName.RdramaShouldntNotify, placeholdersRdrama);
            if (!commentShouldntNotify) throw new Error('No comments for Shouldnt Notify found');
            const postedComment = await CommentPoster.postComment(`c_${comment.id}`, `${commentShouldntNotify}`);
            console.log(`Sent Comment to`, JSON.stringify(postedComment, null, 4));
            return;
        }

        const commentResponseRdrama = MessageService.getRandomMessage(MessageFileName.RdramaMessages, placeholdersRdrama);
        if (!commentResponseRdrama) throw new Error('No comments for Rdrama found');
        const postedComment = await CommentPoster.postComment(`c_${comment.id}`, `${commentResponseRdrama}`);
        console.log(`Sent Comment to`, JSON.stringify(postedComment, null, 4));

        const placeholdersReddit = {
            author_name: comment.author_name,
            username: redditUser,
            permalink: comment.permalink
        };
        const redditMessage = MessageService.getRandomMessage(MessageFileName.RedditMessages, placeholdersReddit);
        if (!redditMessage) throw new Error('No comments for Reddit found');

        await DatabaseService.insertUserMention({
            rdrama_comment_id: comment.id,
            username: redditUser,
            message: redditMessage,
        });
        await RedditService.sendMessage(redditUser, 'Crosstalk PM Notification', redditMessage);
    }
}

export default WorkflowOrchestrator;