n8n-nodes-zalo-custom 1.0.0

package/nodes/ZaloSendMessage/ZaloSendMessage.node.js

@@ -0,0 +1,773 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZaloSendMessage = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const zca_js_1 = require("zca-js");
+const helper_1 = require("../utils/helper");
+const zalo_helper_1 = require("../utils/zalo.helper");
+const ZaloNodeProperties_1 = require("../shared/ZaloNodeProperties");
+const reactionOptions = [
+    { name: 'Heart', value: 'heart' },
+    { name: 'Like', value: 'like' },
+    { name: 'Haha', value: 'haha' },
+    { name: 'Wow', value: 'wow' },
+    { name: 'Cry', value: 'cry' },
+    { name: 'Angry', value: 'angry' },
+    { name: 'Kiss', value: 'kiss' },
+    { name: 'Tears of Joy', value: 'tears_of_joy' },
+    { name: 'Dislike', value: 'dislike' },
+    { name: 'OK', value: 'ok' },
+    { name: 'Thanks', value: 'thanks' },
+    { name: 'Big Smile', value: 'big_smile' },
+    { name: 'Sad', value: 'sad' },
+    { name: 'Very Sad', value: 'very_sad' },
+    { name: 'Rose', value: 'rose' },
+    { name: 'Broken Heart', value: 'broken_heart' },
+    { name: 'Love', value: 'love' },
+    { name: 'Confused', value: 'confused' },
+    { name: 'Wink', value: 'wink' },
+    { name: 'Birthday', value: 'birthday' },
+    { name: 'Bomb', value: 'bomb' },
+    { name: 'Peace', value: 'peace' },
+    { name: 'Pray', value: 'pray' },
+    { name: 'No', value: 'no' },
+    { name: 'Love You', value: 'love_you' },
+    { name: 'Cool', value: 'cool' },
+    { name: 'Nerd', value: 'nerd' },
+    { name: 'Sunglasses', value: 'sunglasses' },
+    { name: 'Neutral', value: 'neutral' },
+    { name: 'Bye', value: 'bye' },
+    { name: 'Sleepy', value: 'sleepy' },
+    { name: 'Wipe', value: 'wipe' },
+    { name: 'Dig', value: 'dig' },
+    { name: 'Handclap', value: 'handclap' },
+    { name: 'Silent', value: 'silent' },
+    { name: 'Surprise', value: 'surprise' },
+    { name: 'Embarrassed', value: 'embarrassed' },
+    { name: 'Afraid', value: 'afraid' },
+    { name: 'Big Laugh', value: 'big_laugh' },
+    { name: 'Beer', value: 'beer' },
+];
+let api;
+function parseHtmlToStyles(html) {
+    var _a, _b;
+    let workingHtml = html
+        .replace(/"/g, '"')
+        .replace(/'/g, "'")
+        .replace(/&lt;/g, '<')
+        .replace(/&gt;/g, '>')
+        .replace(/&amp;/g, '&')
+        .replace(/&nbsp;/g, ' ');
+    workingHtml = workingHtml.replace(/<a[^>]*href="([^"]*)"[^>]*>(.*?)<\/a>/gi, '$2');
+    workingHtml = workingHtml.replace(/<br\s*\/?>/gi, '___BR___');
+    workingHtml = workingHtml.replace(/>\s+</g, '><');
+    workingHtml = workingHtml.replace(/___BR___/g, '<br>');
+    const styles = [];
+    const tagMappings = {
+        'b': 'b',
+        'strong': 'b',
+        'i': 'i',
+        'em': 'i',
+        'u': 'u',
+        's': 's',
+        'strike': 's',
+        'del': 's',
+        'small': 'f_13',
+        'big': 'f_18',
+        'red': 'c_db342e',
+        'orange': 'c_f27806',
+        'yellow': 'c_f7b503',
+        'green': 'c_15a85f',
+    };
+    const openTags = [];
+    let cleanText = '';
+    let htmlIndex = 0;
+    let textIndex = 0;
+    while (htmlIndex < workingHtml.length) {
+        const char = workingHtml[htmlIndex];
+        if (char === '<') {
+            const tagEndIndex = workingHtml.indexOf('>', htmlIndex);
+            if (tagEndIndex === -1) {
+                cleanText += char;
+                textIndex++;
+                htmlIndex++;
+                continue;
+            }
+            const tagContent = workingHtml.substring(htmlIndex + 1, tagEndIndex);
+            const isClosingTag = tagContent.startsWith('/');
+            const tagName = (isClosingTag ? tagContent.substring(1) : tagContent.split(/\s/)[0]).toLowerCase();
+            if (tagName === 'br') {
+                cleanText += '\n';
+                textIndex++;
+            }
+            else if (tagName === 'p') {
+                if (isClosingTag) {
+                    cleanText += '\n\n';
+                    textIndex += 2;
+                }
+            }
+            else if (tagName === 'div') {
+                if (isClosingTag) {
+                    cleanText += '\n';
+                    textIndex++;
+                }
+            }
+            else if (tagName.match(/^h[1-6]$/)) {
+                if (isClosingTag) {
+                    cleanText += '\n';
+                    textIndex++;
+                }
+            }
+            else if (tagName === 'li') {
+                if (!isClosingTag) {
+                    cleanText += '• ';
+                    textIndex += 2;
+                }
+                else {
+                    cleanText += '\n';
+                    textIndex++;
+                }
+            }
+            else if (tagName === 'ul' || tagName === 'ol') {
+                if (!isClosingTag) {
+                    cleanText += '\n';
+                    textIndex++;
+                }
+                else {
+                    cleanText += '\n';
+                    textIndex++;
+                }
+            }
+            else {
+                const styleType = tagMappings[tagName];
+                if (styleType) {
+                    if (isClosingTag) {
+                        for (let i = openTags.length - 1; i >= 0; i--) {
+                            if (openTags[i].tagName === tagName) {
+                                const openTag = openTags[i];
+                                if (textIndex > openTag.startPos) {
+                                    styles.push({
+                                        st: openTag.styleType,
+                                        start: openTag.startPos,
+                                        end: textIndex
+                                    });
+                                }
+                                openTags.splice(i, 1);
+                                break;
+                            }
+                        }
+                    }
+                    else {
+                        openTags.push({
+                            tagName: tagName,
+                            styleType: styleType,
+                            startPos: textIndex
+                        });
+                    }
+                }
+            }
+            htmlIndex = tagEndIndex + 1;
+        }
+        else {
+            cleanText += char;
+            textIndex++;
+            htmlIndex++;
+        }
+    }
+    for (const openTag of openTags) {
+        if (textIndex > openTag.startPos) {
+            styles.push({
+                st: openTag.styleType,
+                start: openTag.startPos,
+                end: textIndex
+            });
+        }
+    }
+    cleanText = cleanText
+        .replace(/\n\s*\n\s*\n/g, '\n\n')
+        .replace(/[ \t]+/g, ' ');
+    const trimStart = ((_b = (_a = cleanText.match(/^\s*/)) === null || _a === void 0 ? void 0 : _a[0]) === null || _b === void 0 ? void 0 : _b.length) || 0;
+    cleanText = cleanText.replace(/^\s+|\s+$/g, '');
+    if (trimStart > 0) {
+        for (const style of styles) {
+            style.start = Math.max(0, style.start - trimStart);
+            style.end = Math.max(style.start, style.end - trimStart);
+        }
+    }
+    return { cleanText, styles };
+}
+
+class ZaloSendMessage {
+    constructor() {
+        this.description = {
+            displayName: 'Zalo Send Message',
+            name: 'zaloSendMessage',
+            icon: 'file:../shared/zalo.svg',
+            group: ['Zalo'],
+            version: 4,
+            documentationUrl: 'https://www.npmjs.com/package/n8n-nodes-zalo/',
+            description: 'Gửi tin nhắn qua API Zalo Credential',
+            defaults: {
+                name: 'Zalo Send Message',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [...ZaloNodeProperties_1.zaloApiCredential],
+            properties: [
+                ...ZaloNodeProperties_1.zaloSessionProperties,
+                {
+                    displayName: 'Thread ID',
+                    name: 'threadId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    description: 'ID của thread để gửi tin nhắn',
+                },
+                {
+                    displayName: 'Type',
+                    name: 'type',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'User',
+                            value: 0,
+                        },
+                        {
+                            name: 'Group',
+                            value: 1,
+                        },
+                    ],
+                    default: 0,
+                    description: 'Tin nhắn gửi đến (người dùng hoặc nhóm)',
+                },
+                {
+                    displayName: 'Message',
+                    name: 'message',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    description: 'Nội dung tin nhắn cần gửi',
+                },
+                {
+                    displayName: 'Message Format',
+                    name: 'messageFormat',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Plain Text',
+                            value: 'plain',
+                        },
+                        {
+                            name: 'HTML (Auto Convert)',
+                            value: 'html',
+                        },
+                    ],
+                    default: 'plain',
+                    description: 'Định dạng tin nhắn: Plain text hoặc HTML tự động chuyển đổi',
+                },
+                {
+                    displayName: 'Urgency',
+                    name: 'urgency',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'Default',
+                            value: 0,
+                        },
+                        {
+                            name: 'Important',
+                            value: 1,
+                        },
+                        {
+                            name: 'Urgent',
+                            value: 2,
+                        },
+                    ],
+                    default: 0,
+                    description: 'Mức độ khẩn cấp của tin nhắn',
+                },
+                {
+                    displayName: 'Image URLs',
+                    name: 'attachmentUrls',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'https://../img1.jpg, https://../img2.png',
+                    description: 'Nhập 1 hoặc nhiều url ảnh cách nhau với dấu (,)',
+                },
+                {
+                    displayName: 'Send "Typing..." Event',
+                    name: 'sendTypingEvent',
+                    type: 'boolean',
+                    default: true,
+                    description: 'Gửi sự kiện "Đang soạn tin..." và đợi một chút trước khi gửi tin nhắn để mô phỏng hành vi của người dùng',
+                },
+                // reaction
+                {
+                    displayName: 'Reaction',
+                    name: 'reaction',
+                    type: 'fixedCollection',
+                    typeOptions: {
+                        multipleValues: false,
+                    },
+                    placeholder: 'Add Reaction',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Reaction Settings',
+                            name: 'reactionValue',
+                            values: [
+                                {
+                                    displayName: 'Reaction Icon',
+                                    name: 'reactionIcon',
+                                    type: 'options',
+                                    options: reactionOptions,
+                                    default: 'heart',
+                                    description: 'Biểu tượng cảm xúc để thể hiện',
+                                },
+                                {
+                                    displayName: 'Message ID',
+                                    name: 'reactionMsgId',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'msgId của tin nhắn hiện có để reaction',
+                                },
+                                {
+                                    displayName: 'Client Message ID',
+                                    name: 'reactionCliMsgId',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'cliMsgId của tin nhắn hiện có để reaction',
+                                },
+                            ],
+                        },
+                    ],
+                },
+
+                {
+                    displayName: 'Quote Message',
+                    name: 'quote',
+                    type: 'fixedCollection',
+                    typeOptions: {
+                        multipleValues: false,
+                    },
+                    placeholder: 'Add Quote',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Quote Details',
+                            name: 'quoteValue',
+                            values: [
+                                {
+                                    displayName: 'User ID',
+                                    name: 'uidFrom',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'ID của người gửi tin nhắn (không phải threadId của group)',
+                                },
+                                {
+                                    displayName: 'Message ID',
+                                    name: 'msgId',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'msgId của tin nhắn cần trích dẫn',
+                                },
+                                {
+                                    displayName: 'Client Message ID',
+                                    name: 'cliMsgId',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'cliMsgId của tin nhắn cần trích dẫn',
+                                },
+                                {
+                                    displayName: 'Content',
+                                    name: 'content',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'Nội dung tin nhắn trích dẫn',
+                                },
+                                {
+                                    displayName: 'Timestamp',
+                                    name: 'ts',
+                                    type: 'number',
+                                    default: 0,
+                                    description: 'Timestamp (ms) của tin nhắn cần trích dẫn',
+                                },
+                                {
+                                    displayName: 'Message Type',
+                                    name: 'msgType',
+                                    type: 'number',
+                                    default: 1,
+                                    description: 'Loại tin nhắn được trích dẫn (ví dụ: 1 cho text)',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Mentions',
+                    name: 'mentions',
+                    type: 'fixedCollection',
+                    typeOptions: {
+                        multipleValues: false,
+                    },
+                    placeholder: 'Add Mention',
+                    default: {},
+                    options: [
+                        {
+                            displayName: 'Mention Details',
+                            name: 'mentionValue',
+                            values: [
+                                {
+                                    displayName: 'User ID',
+                                    name: 'uid',
+                                    type: 'string',
+                                    default: '',
+                                    description: 'ID của người dùng được mention',
+                                },
+                                {
+                                    displayName: 'Position',
+                                    name: 'pos',
+                                    type: 'number',
+                                    default: 0,
+                                    description: 'Vị trí mention trong tin nhắn',
+                                },
+                                {
+                                    displayName: 'Length',
+                                    name: 'len',
+                                    type: 'number',
+                                    default: 0,
+                                    description: 'Độ dài của mention',
+                                },
+                            ],
+                        },
+                    ],
+                },
+                {
+                    displayName: 'Text Styles',
+                    name: 'styles',
+                    type: 'fixedCollection',
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    placeholder: 'Add Text Style',
+                    default: {},
+                    options: [
+                        {
+                            name: 'style',
+                            displayName: 'Style',
+                            values: [
+                                {
+                                    displayName: 'Style Type',
+                                    name: 'st',
+                                    type: 'options',
+                                    options: [
+                                        {
+                                            name: 'Big Font',
+                                            value: 'f_18',
+                                        },
+                                        {
+                                            name: 'Bold',
+                                            value: 'b',
+                                        },
+                                        {
+                                            name: 'Green Color',
+                                            value: 'c_15a85f',
+                                        },
+                                        {
+                                            name: 'Indent',
+                                            value: 'ind_$',
+                                        },
+                                        {
+                                            name: 'Italic',
+                                            value: 'i',
+                                        },
+                                        {
+                                            name: 'Orange Color',
+                                            value: 'c_f27806',
+                                        },
+                                        {
+                                            name: 'Ordered List',
+                                            value: 'lst_2',
+                                        },
+                                        {
+                                            name: 'Red Color',
+                                            value: 'c_db342e',
+                                        },
+                                        {
+                                            name: 'Small Font',
+                                            value: 'f_13',
+                                        },
+                                        {
+                                            name: 'Strike Through',
+                                            value: 's',
+                                        },
+                                        {
+                                            name: 'Underline',
+                                            value: 'u',
+                                        },
+                                        {
+                                            name: 'Unordered List',
+                                            value: 'lst_1',
+                                        },
+                                        {
+                                            name: 'Yellow Color',
+                                            value: 'c_f7b503',
+                                        },
+                                    ],
+                                    default: 'b',
+                                    description: 'Loại style áp dụng cho text',
+                                },
+                                {
+                                    displayName: 'Start Position',
+                                    name: 'start',
+                                    type: 'number',
+                                    default: 0,
+                                    description: 'Vị trí bắt đầu áp dụng style (tính từ 0)',
+                                },
+                                {
+                                    displayName: 'End Position',
+                                    name: 'end',
+                                    type: 'number',
+                                    default: 0,
+                                    description: 'Vị trí kết thúc áp dụng style',
+                                },
+                                {
+                                    displayName: 'Indent Size',
+                                    name: 'indentSize',
+                                    type: 'number',
+                                    default: 1,
+                                    displayOptions: {
+                                        show: {
+                                            'st': ['ind_$'],
+                                        },
+                                    },
+                                    description: 'Kích thước indent (chỉ dùng cho Indent style)',
+                                },
+                            ],
+                        },
+                    ],
+                    description: 'Định dạng text với các style khác nhau',
+                },
+                {
+                    displayName: 'TTL (Time To Live)',
+                    name: 'ttl',
+                    type: 'number',
+                    default: 0,
+                    description: 'Thời gian tồn tại của tin nhắn (giây). 0 = vĩnh viễn.',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const returnData = [];
+        const items = this.getInputData();
+        try {
+            // Use the new helper function to get the API client
+            api = await (0, zalo_helper_1.getZaloApiClient)(this, { needsImageMetadataGetter: true });
+            if (!api) {
+                // The helper function will throw an error, but as a fallback:
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to initialize Zalo API. Check credentials or User ID.');
+            }
+        }
+        catch (error) {
+            this.logger.error(`Zalo login error: ${error.message}`);
+            returnData.push({
+                json: {
+                    success: false,
+                    error: `Zalo login error: ${error.message}`
+                },
+            });
+            return [returnData]
+            // throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Zalo login error: ${error.message}`);
+        }
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const threadId = this.getNodeParameter('threadId', i);
+                const typeNumber = this.getNodeParameter('type', i);
+                const type = typeNumber === 0 ? zca_js_1.ThreadType.User : zca_js_1.ThreadType.Group;
+                const rawMessage = this.getNodeParameter('message', i);
+                const messageFormat = this.getNodeParameter('messageFormat', i, 'plain');
+                const sendTypingEvent = this.getNodeParameter('sendTypingEvent', i, false);
+                const urgency = this.getNodeParameter('urgency', i, 0);
+                const quoteParam = this.getNodeParameter('quote', i, {});
+                const mentionsParam = this.getNodeParameter('mentions', i, {});
+                const manualStyles = this.getNodeParameter('styles', i, {});
+                const ttl = this.getNodeParameter('ttl', i, 0);
+                const attachmentUrls = this.getNodeParameter('attachmentUrls', i, '');
+                const reactionParam = this.getNodeParameter('reaction', i, {});
+
+                // return json
+                const returnJson = {
+                    threadId,
+                    threadType: type
+                };
+                let reactionIcon;
+                let reactionMsgId;
+                let reactionCliMsgId;
+                if (reactionParam && reactionParam.reactionValue && Object.keys(reactionParam.reactionValue).length > 0) {
+                    const r = reactionParam.reactionValue;
+                    const reactionKey = (r.reactionIcon || 'heart').toUpperCase();
+                    reactionIcon = zca_js_1.Reactions[reactionKey] || zca_js_1.Reactions.HEART;
+                    reactionMsgId = r.reactionMsgId || '';
+                    reactionCliMsgId = r.reactionCliMsgId || '';
+                }
+
+                let message = rawMessage;
+                let styles = manualStyles;
+                if (messageFormat === 'html') {
+                    const parsed = parseHtmlToStyles(rawMessage);
+                    message = parsed.cleanText;
+                    const htmlStyles = parsed.styles;
+                    const manualStylesArray = manualStyles && manualStyles.style ? manualStyles.style : [];
+                    styles = {
+                        style: [...htmlStyles, ...manualStylesArray]
+                    };
+                    this.logger.info(`HTML parsed: "${rawMessage}" -> "${message}" with ${htmlStyles.length} styles`);
+                    this.logger.info(`Parsed styles: ${JSON.stringify(htmlStyles, null, 2)}`);
+                }
+                const messageContent = {
+                    msg: message,
+                };
+                if (urgency !== 0) {
+                    messageContent.urgency = urgency;
+                }
+                if (ttl !== 0) {
+                    messageContent.ttl = ttl;
+                }
+
+                if (styles && styles.style && styles.style.length > 0) {
+                    messageContent.styles = styles.style.map((style) => ({
+                        st: style.st,
+                        start: style.start,
+                        len: style.end - style.start,
+                        indentSize: style.st === 'ind_$' ? style.indentSize : undefined,
+                    }));
+                }
+                if (quoteParam && quoteParam.quoteValue && Object.keys(quoteParam.quoteValue).length > 0) {
+                    const quote = quoteParam.quoteValue;
+                    if (quote.uidFrom && quote.msgId && quote.cliMsgId && quote.content) {
+                        if (typeNumber === 1 && quote.uidFrom === threadId) {
+                            returnJson.quoteError = 'tại Nhóm: cần cung cấp ID người gửi tin nhắn thay vì threadId';
+                        } else {
+                            messageContent.quote = {
+                                uidFrom: quote.uidFrom,
+                                msgId: quote.msgId,
+                                cliMsgId: quote.cliMsgId,
+                                content: quote.content,
+                                ts: quote.ts || Date.now(),
+                                msgType: quote.msgType || 1,
+                            };
+                        }
+                    } else {
+                        this.logger.warn(`..quote: thiếu thông tin: uidFrom, msgId, cliMsgId, content.`);
+                        returnJson.quoteError = 'thiếu thông tin trích dẫn';
+                    }
+                }
+                if (mentionsParam && mentionsParam.mentionValue && Object.keys(mentionsParam.mentionValue).length > 0) {
+                    const mentions = mentionsParam.mentionValue;
+                    if (mentions.uid) {
+                        messageContent.mentions = [{
+                                pos: mentions.pos || 0,
+                                uid: mentions.uid,
+                                len: mentions.len || 0,
+                            }];
+                    }
+                }
+                if (attachmentUrls && attachmentUrls.trim() !== '') {
+                    const urls = attachmentUrls.split(',').map(url => url.trim()).filter(url => url);
+                    messageContent.attachments = [];
+                    for (const url of urls) {
+                        try {
+                            // Validate URL format
+                            new URL(url);
+                            // Download file and get its local path
+                            const fileData = await (0, helper_1.saveFile)(url);
+                            messageContent.attachments.push(fileData);
+                            this.logger.info(`Successfully prepared attachment from URL: ${url}`);
+                        }
+                        catch (e) {
+                            // Log a warning and skip if the URL is invalid or the file can't be downloaded
+                            this.logger.warn(`Skipping invalid or inaccessible attachment URL: ${url}. Error: ${e.message}`);
+                        }
+                    }
+                }
+
+                this.logger.info(`Sending message with parameters: ${JSON.stringify(messageContent)}`);
+                this.logger.info(`Final styles being sent: ${JSON.stringify(messageContent.styles || 'No styles')}`);
+                if (!api) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Zalo API not initialized');
+                }
+
+                if (sendTypingEvent) {
+                    try {
+                        const result = await api.sendTypingEvent(threadId, type);
+                        if (result) {
+                            this.logger.info("Sent 'typing' event, waiting for second...");
+                            returnJson.typing = true;
+                            await new Promise(resolve => setTimeout(resolve, 1500));
+                        }
+                        else {
+                            this.logger.warn("'typing' event was sent but returned a falsy result.");
+                            returnJson.typing = false;
+                        }
+                    }
+                    catch (e) {
+                        this.logger.warn(`Could not send 'typing' event: ${e.message}`);
+                        returnJson.typing = false;
+                    }
+                }
+                const response = await api.sendMessage(messageContent, threadId, type);
+                returnJson.success = true;
+                returnJson.sendMessageResponse = response;
+                returnJson.sendMessageValue = messageContent;
+                if (reactionIcon && reactionMsgId && reactionCliMsgId) {
+                    this.logger.info('Waiting 1 second before sending reaction...');
+                    await new Promise(resolve => setTimeout(resolve, 1000));
+                    try {
+                        const addReactionDestination = {
+                            data: {
+                                msgId: reactionMsgId,
+                                cliMsgId: reactionCliMsgId,
+                            },
+                            threadId,
+                            type,
+                        };
+                        const reactionResponse = await api.addReaction(reactionIcon, addReactionDestination);
+                        this.logger.info(`Successfully sent reaction '${reactionIcon}' to message ${reactionMsgId}`);
+                        returnJson.reactionSuccess = true;
+                        returnJson.reactionResponse = reactionResponse;
+                    }
+                    catch (reactionError) {
+                        this.logger.warn(`Failed to send reaction: ${reactionError.message}`);
+                        returnJson.reactionSuccess = false;
+                        returnJson.reactionError = reactionError.message;
+                    }
+                }
+                if (messageContent.attachments && messageContent.attachments.length > 0) {
+                    for (const attachment of messageContent.attachments) {
+                        this.logger.info(`Remove attachment: ${attachment}`);
+                        (0, helper_1.removeFile)(attachment);
+                    }
+                }
+                this.logger.info('Message sent successfully', { threadId, type });
+                returnData.push({ json: returnJson });
+            }
+            catch (error) {
+                this.logger.error('Error sending Zalo message:', error);
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            success: false,
+                            error: error.message,
+                        },
+                    });
+                }
+                else {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, { itemIndex: i });
+                }
+            }
+        }
+        return [returnData];
+    }
+}
+exports.ZaloSendMessage = ZaloSendMessage;