n8n-nodes-zalo-custom 1.0.9 → 1.1.0

package/nodes/ZaloSendMessage/ZaloSendMessageDescription.js

@@ -0,0 +1,389 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZaloSendMessageDescription = exports.reactionOptions = void 0;
+exports.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' },
+];
+
+exports.ZaloSendMessageDescription = [
+    {
+        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',
+                value: 'html',
+            },
+        ],
+        default: 'plain',
+        description: 'Định dạng mặc định hoặc HTML',
+    },
+    {
+        displayName: 'Urgency',
+        name: 'urgency',
+        type: 'options',
+        options: [
+            {
+                name: 'Default',
+                value: 0,
+                description: 'Tin nhắn mặc định',
+            },
+            {
+                name: 'Important',
+                value: 1,
+                description: 'Đánh dấu tin nhắn quan trọng',
+            },
+            {
+                name: 'Urgent',
+                value: 2,
+                description: 'Người nhận được thông báo nhiều lần trong vài phút',
+            },
+        ],
+        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..." (tự động chờ 1 chút trước khi gửi tin)',
+    },
+    {
+        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: exports.reactionOptions,
+                        default: 'heart',
+                        description: 'Biểu tượng cảm xúc',
+                    },
+                    {
+                        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.',
+    },
+];

package/nodes/ZaloTrigger/ZaloTrigger.node.js

@@ -200,8 +200,7 @@ class ZaloTrigger {
             continueOnFail: continueOnFail,
         };
 
-        let telegramToken;
-        let telegramChatId;
+        let telegramToken, telegramChatId, telegramOptions;
         if (continueOnFail) {
             const tokenOverride = this.getNodeParameter('telegramTokenOverride', 0, '');
             const chatIdOverride = this.getNodeParameter('telegramChatIdOverride', 0, '');
@@ -211,12 +210,25 @@ class ZaloTrigger {
             telegramChatId = chatIdOverride || credsChatId;
             if (!telegramToken || !telegramChatId) {
                 context.errorNotification = 'Vui lòng cung cấp BotToken và Chat_id để nhận thông báo khi phát hiện lỗi';
+            } else {
+                telegramOptions = {
+                    token: telegramToken,
+                    chatId: telegramChatId,
+                    logger: this.logger,
+                };
             }
         }
+        const sendTelegramNotification = (message) => {
+            if (telegramOptions) {
+                (0, zalo_helper_1.sendToTelegram)({
+                    ...telegramOptions,
+                    text: message,
+                }).catch(e => this.logger.error(`Failed to send Telegram notification: ${e.message}`));
+            }
+        };
 
         let api = apiInstances.get(instanceKey);
         let closeFunction = async () => { };
-
         try {
             if (apiInstances.has(instanceKey)) {
                 this.logger.info(`Instance ${instanceKey} already exists, reusing...`);
@@ -226,7 +238,6 @@ class ZaloTrigger {
                 if (!api) {
                     throw new Error('No API instance found. Please make sure to provide valid credentials.');
                 }
-
                 try {
                     const fetchedInfo = await api.fetchAccountInfo();
                     if (fetchedInfo && fetchedInfo.profile) {
@@ -261,7 +272,6 @@ class ZaloTrigger {
                 catch (err) {
                     this.logger.error(`[Zalo ${mode}] Failed to fetch account info: ${err.message}`);
                 }
-
                 apiInstances.set(instanceKey, api);
             }
 
@@ -270,7 +280,6 @@ class ZaloTrigger {
                 if (!data?.isSelf) {
                     context.logger.info(`[${apiInstances.size}] [Zalo ${context.mode} received] ${context.credentialPhone}: ${eventType}`);
                 }
-
                 const dataWithContext = {
                     ...data,
                     _timestamp: new Date().toISOString(),
@@ -283,7 +292,6 @@ class ZaloTrigger {
                     _eventType: eventType,
                     _source: 'zalo_trigger',
                 };
-
                 const webhookData = this.getWorkflowStaticData('node');
                 if (!webhookData[context.instanceKey]) {
                     webhookData[context.instanceKey] = {};
@@ -299,7 +307,6 @@ class ZaloTrigger {
 
                 emitEvent(dataWithContext);
             };
-
             if (context.eventTypes.includes('message_user') || context.eventTypes.includes('message_group')) {
                 api.listener.on('message', async (message) => {
                     const eventType = message.type === threadTypeUser ? 'message_user' : 'message_group';
@@ -349,35 +356,30 @@ class ZaloTrigger {
                     await handleEvent(message, eventType);
                 });
             }
-
             if (context.eventTypes.includes('reaction')) {
                 api.listener.on('reaction', async (reaction) => {
                     if (context.ignoreSelfEvents && reaction.isSelf) return;
                     await handleEvent(reaction, 'reaction');
                 });
             }
-
             if (context.eventTypes.includes('undo')) {
                 api.listener.on('undo', async (undo) => {
                     if (context.ignoreSelfEvents && undo.isSelf) return;
                     await handleEvent(undo, 'undo');
                 });
             }
-
             if (context.eventTypes.includes('group_event')) {
                 api.listener.on('group_event', async (groupEvent) => {
                     if (context.ignoreSelfEvents && groupEvent.isSelf) return;
                     await handleEvent(groupEvent, 'group_event');
                 });
             }
-
             if (context.eventTypes.includes('friend_request')) {
                 api.listener.on('friend_event', async (friendEvent) => {
                     if (context.ignoreSelfEvents && friendEvent.isSelf) return;
                     await handleEvent(friendEvent, 'friend_request');
                 });
             }
-
             if (context.eventTypes.includes('seen_message')) {
                 api.listener.on('seen_messages', async (seenMessages) => {
                     for (const seen of seenMessages) {
@@ -387,7 +389,6 @@ class ZaloTrigger {
                     }
                 });
             }
-
             if (context.eventTypes.includes('typing')) {
                 api.listener.on('typing', async (typing) => {
                     if (seen.type === threadTypeUser &&  !seen.isSelf) {
@@ -396,7 +397,22 @@ class ZaloTrigger {
                 });
             }
 
-            // Start listening
+            api.listener.on('disconnected', (code, reason) => {
+                context.logger.warn(`[Zalo ${context.mode}] disconnected: ${currentPhone} - ${code}: "${reason || 'No reason'}". Attempting to reconnect...`);
+                if (reason !== 'NORMAL_CLOSURE') {
+                    sendTelegramNotification(`[Zalo ${context.mode}] disconnected: ${currentPhone}: err: "${reason || 'No reason'}". Attempting to reconnect...`);
+                }
+            });
+            api.listener.on('closed', (code, reason) => {
+                context.logger.warn(`[Zalo ${context.mode}] closed: ${currentPhone} - ${code}: "${reason || 'No reason'}" (stop trigger)`);
+                if (reason !== 'NORMAL_CLOSURE') {
+                    sendTelegramNotification(`[Zalo ${context.mode}] closed: ${currentPhone}: err: "${reason || 'No reason'}" (stop trigger)`);
+                }
+            });
+            api.listener.on('error', (error) => {
+                const errorMessage = error instanceof Error ? error.message : JSON.stringify(error);
+                context.logger.warn(`[Zalo ${context.mode}] WebSocket Error: ${currentPhone} - ${errorMessage}`);
+            });
             api.listener.start({ retryOnClose: true });
             this.logger.info(`[${apiInstances.size}] [Zalo ${mode}] Listening: ${currentPhone} - ${currentName} (${context.eventTypes})`);
 
@@ -497,14 +513,8 @@ class ZaloTrigger {
         catch (error) {
             const continueOnFail = this.getNodeParameter('continueOnFail', 0, false);
             if (continueOnFail && mode !== 'manual') {
-                if (telegramToken && telegramChatId) {
-                    const errorMessage = `⚠️ **Lỗi Kích Hoạt Zalo Trigger**\n\n- Tài khoản: ${currentName}\n- SĐT: ${currentPhone}\n- Lý do: ${error.message} (bỏ qua node này tiếp tục active workflow)`;
-                    (0, zalo_helper_1.sendToTelegram)({
-                        token: telegramToken,
-                        chatId: telegramChatId,
-                        text: errorMessage,
-                    }).catch(e => this.logger.error(`Failed to send Telegram notification: ${e.message}`));
-                }
+                const errorMessage = `⚠️ **Lỗi Kích Hoạt Zalo Trigger**\n\n- Tài khoản: ${currentName}\n- SĐT: ${currentPhone}\n- Lý do: ${error.message} (bỏ qua node này tiếp tục active workflow)`;
+                sendTelegramNotification(errorMessage);
                 return {
                     closeFunction: async () => { },
                     manualTriggerFunction: async () => true,

package/nodes/ZaloUploadAttachment/ZaloUploadAttachment.node.js

@@ -7,6 +7,7 @@ exports.ZaloUploadAttachment = 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 fs_1 = __importDefault(require("fs"));
 let api;
 class ZaloUploadAttachment {
@@ -149,34 +150,16 @@ class ZaloUploadAttachment {
     async execute() {
         const returnData = [];
         const items = this.getInputData();
-        const zaloCred = await this.getCredentials('zaloApi');
-        const cookieFromCred = JSON.parse(zaloCred.cookie);
-        const imeiFromCred = zaloCred.imei;
-        const userAgentFromCred = zaloCred.userAgent;
         try {
-            const zalo = new zca_js_1.Zalo({
-                selfListen: false,
-                logging: true,
-                imageMetadataGetter: async (filePath) => {
-                    return {
-                        width: 0,
-                        height: 0,
-                        size: 0
-                    };
-                }
-            });
-            api = await zalo.login({
-                cookie: cookieFromCred,
-                imei: imeiFromCred,
-                userAgent: userAgentFromCred
-            });
+            api = await (0, zalo_helper_1.getZaloApiClient)(this, { needsImageMetadataGetter: true, selfListen: true });
             if (!api) {
-                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to initialize Zalo API. Check your credentials.');
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to initialize Zalo API. Check credentials or User ID.');
             }
         }
         catch (error) {
             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);
@@ -188,12 +171,29 @@ class ZaloUploadAttachment {
                 }
                 const sources = [];
                 const tempFiles = [];
+
+                const path_1 = __importDefault(require("path"));
+                const os_1 = __importDefault(require("os"));
+                const n8nUserFolder = process.env.N8N_USER_FOLDER || path_1.default.join(os_1.default.homedir(), '.n8n');
+
                 for (const sourceConfig of sourcesData.source) {
                     let source;
                     if (sourceConfig.type === 'filePath') {
-                        const filePath = sourceConfig.filePath;
+                        let filePath = sourceConfig.filePath;
                         if (!fs_1.default.existsSync(filePath)) {
-                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `File không tồn tại: ${filePath}`);
+                            const relativePath = path_1.default.join(n8nUserFolder, filePath);
+                            const tempPath = path_1.default.join(n8nUserFolder, 'temp_files', path_1.default.basename(filePath));
+
+                            if (fs_1.default.existsSync(relativePath)) {
+                                filePath = relativePath;
+                                this.logger.info(`Resolved relative path: ${filePath}`);
+                            } else if (fs_1.default.existsSync(tempPath)) {
+                                filePath = tempPath;
+                                this.logger.info(`Resolved temp path: ${filePath}`);
+                            } else {
+                                this.logger.error(`File path not found: ${sourceConfig.filePath}`);
+                                throw new n8n_workflow_1.NodeOperationError(this.getNode(), `File không tồn tại: ${sourceConfig.filePath}. (Đã thử tìm tại: ${relativePath})`);
+                            }
                         }
                         source = filePath;
                     }
@@ -203,6 +203,7 @@ class ZaloUploadAttachment {
                         if (!tempFilePath) {
                             throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Không thể tải file từ URL: ${fileUrl}`);
                         }
+                        this.logger.info(`Downloaded URL to temp file: ${tempFilePath}`);
                         tempFiles.push(tempFilePath);
                         source = tempFilePath;
                     }
@@ -226,9 +227,6 @@ class ZaloUploadAttachment {
                     sources.push(source);
                 }
                 this.logger.info(`Uploading ${sources.length} file(s) to thread ${threadId} (${threadTypeStr})`);
-                if (!api) {
-                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Zalo API not initialized');
-                }
                 const uploadResults = await api.uploadAttachment(sources, threadId, threadType);
                 for (const tempFile of tempFiles) {
                     (0, helper_1.removeFile)(tempFile);

package/nodes/ZaloUploadAttachment/ZaloUploadAttachmentDescription.js

@@ -53,7 +53,7 @@ exports.ZaloUploadAttachmentDescription = {
                 {
                     name: 'File Path',
                     value: 'filePath',
-                    description: 'Đường dẫn file trên server n8n',
+                    description: 'Đường dẫn file (nên lưu tại: /home/node/.n8n/temp_files)',
                 },
                 {
                     name: 'URL',