node-red-contrib-whatsapp-link/group-out.js

const { formatGroupId, formatGroupIdSocket } = require('./whatsapp-utils');

module.exports = function(RED) {
    function WhatsappGroupOut(config) {
        RED.nodes.createNode(this,config);
        var node = this;
        
        // Get group ID from recipient config node if configured
        var recipientNode = RED.nodes.getNode(config.recipient);
        node.number = recipientNode ? recipientNode.groupId : null;
        
        var whatsappLinkNode = RED.nodes.getNode(config.whatsappLink);
        node.waClient = whatsappLinkNode.client;

        const { MessageMedia, Buttons } = require('whatsapp-web.js')

        let SetStatus = function(WAStatus, color){
            node.status({fill:color,shape:"dot",text:WAStatus});
        };
        const delay = ms => new Promise(resolve => setTimeout(resolve, ms));

        async function whatsappMessage(gID , inputMessage){
            // Validate message
            if (!inputMessage) {
                node.error('Error Sending Msg: Message payload is empty or undefined');
                SetStatus("Message empty", "red");
                setTimeout(() => SetStatus('Connected','green'), 3000);
                return;
            }
            
            if (node.waClient.clientType === "waWebClient"){
                try {
                    gID = await formatGroupId(gID, node.waClient, node);
                    
                    // Ensure message is a string for simple messages
                    if(typeof inputMessage === "object" && inputMessage.buttons){
                        inputMessage = new Buttons(inputMessage.text, inputMessage.buttons, "text" ,inputMessage.footer);
                        await node.waClient.sendMessage(gID, inputMessage);
                    } else if (typeof inputMessage === "object") {
                        // If it's an object without buttons, convert to string or handle appropriately
                        const messageText = inputMessage.text || JSON.stringify(inputMessage);
                        await node.waClient.sendMessage(gID, messageText);
                    } else {
                        // Convert to string to ensure valid message
                        await node.waClient.sendMessage(gID, String(inputMessage));
                    }
                }
                catch(e){
                    node.error(`Error Sending Msg: ${e}`);
                }
            } 
            else if (node.waClient.clientType === "waSocketClient"){
                try {
                    let client = await node.waClient;
                    gID = await formatGroupIdSocket(gID, node.waClient, node);
                    
                    // Format message for socket client
                    if (typeof inputMessage === "string"){
                        inputMessage = {text : inputMessage};
                    } else if (typeof inputMessage === "object" && !inputMessage.text) {
                        // If object doesn't have text property, convert to string
                        inputMessage = {text : JSON.stringify(inputMessage)};
                    }
                    
                    await client.sendMessage(gID, inputMessage);
                }
                catch(e) {
                    node.error(`Error Sending Msg: ${e}`);
                }
            } 
            else { 
                node.error(`Error Sending Msg: Unknown client type`)
            }
            SetStatus("Message Send.", "green");
            setTimeout(()=>{
                SetStatus('Connected','green');
            }, 2000)
        };

        async function whatsappMultiMediaMessage(gID, whatsappImage, whatsappCaption){
            try {
                if (node.waClient.clientType === "waWebClient"){
                    gID = await formatGroupId(gID, node.waClient, node);
                    var whatsappImageBase64 = whatsappImage.split(',')[1] || whatsappImage;
                    var myMessage = new MessageMedia('image/png', whatsappImageBase64, null, null);
                    await node.waClient.sendMessage(gID, myMessage, {caption : whatsappCaption || "Image from Node-Red"});
                } 
                else {
                    gID = await formatGroupIdSocket(gID, node.waClient, node);
                    var whatsappImageBase64 = whatsappImage.split(',')[1] || whatsappImage;
                    let imageToSend = Buffer.from(whatsappImageBase64, "base64");
                    const imageMessage = { 
                        image: imageToSend, 
                        caption: whatsappCaption || "Image from Node-Red"
                    }

                    let client = await node.waClient;
                    await client.sendMessage(gID, imageMessage);
                }              
                SetStatus("Message Send.", "green");
                setTimeout(()=>{
                    SetStatus('Connected','green');
                }, 2000)
            } catch(e) {
                node.error(`Error sending MultiMedia Message : ${e}`)
            }
        };

        node.on('input', (message)=> {
            if (node.number){
                if (message.image){
                    whatsappMultiMediaMessage(node.number, message.image, message.payload);       
                }  
                else {
                    whatsappMessage(node.number, message.payload);
                }

            } else if (message.toNumber){
                var numbers = message.toNumber instanceof Array ? message.toNumber : Array.of(message.toNumber);
                for (number of numbers) {
                    if(message.image){
                        whatsappMultiMediaMessage(number, message.image, message.payload)
                        delay(2000);

                    } else {
                        whatsappMessage(number, message.payload)
                        delay(2000)
                    }
                }
            } else if(message.key.remoteJid){
                whatsappMessage(message.key, message.payload)
            } 
            else {
                SetStatus("No number","red");
                setTimeout(()=>{
                    SetStatus('Connected','green');
                }, 5000)
            }
        });

        //whatsapp Status Parameters----
        if (node.waClient.clientType === "waWebClient"){
            node.waClient.on('qr', (qr) => {
                SetStatus("QR Code Generated", "yellow");
            });
            
            node.waClient.on('auth_failure', () => {
                SetStatus('Not Connected','red');
            });
                    
            node.waClient.on('loading_screen', () => {
                SetStatus('Connecting...','yellow');
            });
            
            node.waClient.on('ready', () => {
                SetStatus('Connected','green');
            });

            node.waClient.on('disconnected', () => {
                SetStatus("Disconnected","red");
            });

        } else if (node.waClient.clientType === "waSocketClient"){
            async function checkStatusOfSockets(){
                let client = await node.waClient;
                client.ev.on('connection.update', (updates)=>{
                    var {connection} = updates
                    if(connection === 'open'){
                        SetStatus("Connected", "green");
                    }
                    else if(updates.isOnline){
                        SetStatus("Connected", "green");
                    }
                    else if(connection === 'close'){
                        SetStatus("Disconnected", "red");
                    }
                    else if(connection === 'connecting'){
                        SetStatus("Connecting...", "yellow");
                    }
                    else if(updates.qr){
                        SetStatus("Scan QR Code to Connect.", "yellow");
                    }
                })
            }
            checkStatusOfSockets();

        }

   
    }
    RED.nodes.registerType("group-out", WhatsappGroupOut);
}