n8n-nodes-zalo-custom 1.0.0

package/nodes/ZaloTrigger/ZaloTrigger.node.js

@@ -0,0 +1,609 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZaloTrigger = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const ZaloNodeProperties_1 = require("../shared/ZaloNodeProperties");
+const zca_js_1 = require("zca-js");
+const zalo_helper_1 = require("../utils/zalo.helper");
+const apiInstances = new Map();
+const reconnectTimers = new Map();
+const messageQueue = new Map();
+const threadTypeUser = zca_js_1.ThreadType.User;
+class ZaloTrigger {
+    constructor() {
+        this.description = {
+            displayName: 'Zalo Trigger',
+            name: 'zaloApiTrigger',
+            icon: 'file:../shared/zalo.svg',
+            group: ['trigger'],
+            version: 1,
+            description: 'Sự kiện lắng nghe tin nhắn trên Zalo (multiple users)',
+            defaults: {
+                name: 'Zalo Trigger',
+            },
+            inputs: [],
+            outputs: ['main'],
+            webhooks: [
+                {
+                    name: 'default',
+                    httpMethod: 'POST',
+                    responseMode: 'onReceived',
+                    path: 'webhook',
+                },
+            ],
+            credentials: [...ZaloNodeProperties_1.zaloApiCredential],
+            properties: [
+                ...ZaloNodeProperties_1.zaloSessionProperties,
+                {
+                    displayName: 'Event Types',
+                    name: 'eventTypes',
+                    type: 'multiOptions',
+                    options: [
+                        {
+                            name: 'User Messages',
+                            value: 'message_user',
+                            description: 'Lắng nghe tin nhắn từ người dùng',
+                        },
+                        {
+                            name: 'Group Messages',
+                            value: 'message_group',
+                            description: 'Lắng nghe tin nhắn từ nhóm',
+                        },
+                        {
+                            name: 'Reaction',
+                            value: 'reaction',
+                            description: 'Sự kiện thả cảm xúc vào tin nhắn',
+                        },
+                        {
+                            name: 'Undo',
+                            value: 'undo',
+                            description: 'Sự kiện thu hồi tin nhắn',
+                        },
+                        {
+                            name: 'Group Event',
+                            value: 'group_event',
+                            description: 'Sự kiện của nhóm (tham gia, rời đi, thăng cấp..)',
+                        },
+                        {
+                            name: 'Friend Event',
+                            value: 'friend_request',
+                            description: 'Sự kiện có người gửi yêu cầu kết bạn',
+                        },
+                    ],
+                    default: ['message_user', 'message_group'],
+                    required: true,
+                    description: 'Các loại sự kiện muốn lắng nghe',
+                },
+                {
+                    displayName: 'Filtering Thread IDs',
+                    name: 'threadIdFiltering',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            eventTypes: [
+                                'message_user',
+                                'message_group',
+                            ],
+                        },
+                    },
+                    description: 'Chỉ định ID nhóm nhận sự kiện User/Group Message',
+                },
+                {
+                    displayName: 'Allowed Thread IDs',
+                    name: 'listenOnlyThreads',
+                    type: 'string',
+                    typeOptions: {
+                        textArea: true,
+                    },
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            threadIdFiltering: [
+                                true,
+                            ],
+                        },
+                    },
+                    description: 'Chỉ lắng nghe tin nhắn từ các thread ID này (phân cách bằng dấu phẩy). Nếu để trống, sẽ lắng nghe tất cả.',
+                    placeholder: 'threadId1,threadId2,threadId3',
+                },
+                {
+                    displayName: 'Blocked Thread IDs',
+                    name: 'ignoreThreads',
+                    type: 'string',
+                    typeOptions: {
+                        textArea: true,
+                    },
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            threadIdFiltering: [
+                                true,
+                            ],
+                        },
+                    },
+                    description: 'Bỏ qua tin nhắn từ các thread ID này (phân cách bằng dấu phẩy).',
+                    placeholder: 'threadId4,threadId5',
+                },
+                {
+                    displayName: 'Filtering Keyword',
+                    name: 'keywordFiltering',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            eventTypes: [
+                                'message_user',
+                                'message_group',
+                            ],
+                        },
+                    },
+                    description: 'Lọc tin nhắn theo từ khoá khi nhận sự kiện User/Group Message',
+                },
+                {
+                    displayName: 'Listen Only Keywords',
+                    name: 'listenOnlyKeywords',
+                    type: 'string',
+                    typeOptions: {
+                        textArea: true,
+                    },
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            keywordFiltering: [
+                                true,
+                            ],
+                        },
+                    },
+                    description: 'Chỉ lắng nghe tin nhắn chứa ít nhất một trong các từ khóa này (phân cách bằng dấu phẩy). Bỏ qua các từ khóa chỉ có 1 ký tự. Không phân biệt chữ hoa/thường.',
+                    placeholder: 'ok, chào, tin tức',
+                },
+                {
+                    displayName: 'Ignore Keywords',
+                    name: 'ignoreKeywords',
+                    type: 'string',
+                    typeOptions: {
+                        textArea: true,
+                    },
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            keywordFiltering: [
+                                true,
+                            ],
+                        },
+                    },
+                    description: 'Bỏ qua tin nhắn chứa bất kỳ từ khóa nào trong danh sách này (phân cách bằng dấu phẩy). Bỏ qua các từ khóa chỉ có 1 ký tự. Không phân biệt chữ hoa/thường.',
+                    placeholder: 'spam, quảng cáo',
+                },
+
+                {
+                    displayName: 'Self Listen',
+                    name: 'selfListen',
+                    type: 'boolean',
+                    default: false,
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            eventTypes: [
+                                'message_user',
+                                'message_group',
+                                'reaction',
+                                'undo',
+                                'group_event',
+                                'friend_request',
+                            ],
+                        },
+                    },
+                    description: 'Lắng nghe các sự kiện do chính bạn thực hiện.',
+                },
+                {
+                    displayName: 'Self Messages Only',
+                    name: 'ignoreSelfEvents',
+                    type: 'boolean',
+                    default: true,
+                    displayOptions: {
+                        show: {
+                            selfListen: [
+                                true,
+                            ],
+                        },
+                    },
+                    description: 'Self Listen chỉ nhận sự kiện User/Group Message (bỏ qua: Thả icon, Thu hồi, Sự kiện nhóm, Kết bạn)',
+                },
+                {
+                    displayName: 'Continue On Login Fail',
+                    name: 'continueOnFail',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            eventTypes: [
+                                'message_user',
+                                'message_group',
+                                'reaction',
+                                'undo',
+                                'group_event',
+                                'friend_request',
+                            ],
+                        },
+                    },
+                    description: 'Tiếp tục active workflow kể cả khi có 1 Zalo Trigger lỗi (cần bật ở mọi nút. Hiệu quả khi có nhiều trigger trong workflow)',
+                },
+                {
+                    displayName: 'Telegram Bot Token',
+                    name: 'telegramTokenOverride',
+                    type: 'string',
+                    typeOptions: {
+                        password: false,
+                    },
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            continueOnFail: [true],
+                        },
+                    },
+                    description: 'Bot token dùng để thông báo khi trigger lỗi (để trống nếu credential đã có sẵn)',
+                },
+                {
+                    displayName: 'Telegram Chat ID',
+                    name: 'telegramChatIdOverride',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            continueOnFail: [true],
+                        },
+                    },
+                    description: 'ID nhóm chat dùng để thông báo khi trigger lỗi (để trống nếu credential đã có sẵn)',
+                },
+            ],
+        };
+        this.webhookMethods = {
+            default: {
+                async checkExists() {
+                    const credentials = await this.getCredentials('zaloApi');
+                    const useSession = this.getNodeParameter('useSession', 0, false);
+                    const keyId = useSession ? this.getNodeParameter('connectToId', 0, '') : (credentials ? credentials.userId : '');
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+                    const instanceKey = webhookUrl?.includes('/webhook-test/')
+                        ? `${keyId}-test`
+                        : `${keyId}`;
+					const isConnected = apiInstances.has(instanceKey);
+                    if (isConnected) {
+                        this.logger.info(`checkExists: ${isConnected ? 'LIVE' : 'NOT LIVE'} : "${instanceKey}"`);
+                    }
+
+                    return isConnected;
+                },
+                async create() {
+                    const credentials = await this.getCredentials('zaloApi');
+                    const useSession = this.getNodeParameter('useSession', 0, false);
+                    const keyId = useSession ? this.getNodeParameter('connectToId', 0, '') : (credentials ? credentials.userId : '');
+                    let currentUserId = credentials ? credentials.userId : 'N/A';
+                    let currentName = credentials ? credentials.nameAccount : 'N/A';
+                    let currentPhone = credentials ? credentials.phoneNumber : 'N/A';
+                    const mode = this.getMode(); // 'trigger' or 'manual'
+                    const selfListen = this.getNodeParameter('selfListen', 0, false);
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+
+                    const instanceKey = webhookUrl?.includes('/webhook-test/')
+                        ? `${keyId}-test`
+                        : `${keyId}`;
+                    const productionKey = `${keyId}`;
+                    const testKey = `${keyId}-test`;
+
+                    if (webhookUrl?.includes('/webhook-test/') && apiInstances.has(productionKey)) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Zalo trigger: Please deactivate the workflow before testing`);
+                    }
+                    if (!webhookUrl?.includes('/webhook-test/') && apiInstances.has(testKey)) {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Zalo trigger: Please turn off the test listening then try Active Workflow`);
+                    }
+
+                    if (apiInstances.has(instanceKey)) {
+                        this.logger.info(`Instance ${instanceKey} already exists, reusing...`);
+                        const webhookData = this.getWorkflowStaticData('node');
+                        webhookData[instanceKey] = {
+                            isConnected: true,
+                            eventTypes: this.getNodeParameter('eventTypes', 0),
+                            createdAt: new Date().toISOString()
+                        };
+                        return true;
+                    }
+
+
+                    try {
+                        const api = await (0, zalo_helper_1.getZaloApiClient)(this, { selfListen });
+                        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) {
+                                const newUserId = fetchedInfo.profile.userId;
+                                const newRawPhone = fetchedInfo.profile.phoneNumber || '';
+                                const newPhone = newRawPhone.replace(/^(\+84)/, '0');
+                                const newName = fetchedInfo.profile.zaloName;
+                                currentUserId = newUserId;
+                                currentName = newName;
+                                currentPhone = newPhone;
+                                const hasNameChanged = credentials && newName && newName !== credentials.nameAccount;
+                                const hasPhoneChanged = credentials && newPhone && newPhone !== credentials.phoneNumber;
+                                if (newUserId && (hasNameChanged || hasPhoneChanged)) {
+                                    try {
+                                        await (0, zalo_helper_1.updateSessionInfo)(newUserId, newName, newPhone);
+                                        // this.logger.info(`Account info for ${newUserId} has changed: database updated session.`);
+                                    } catch (dbError) {
+                                        this.logger.error(`[Zalo ${mode}] Failed to update user: ${newUserId}: ${dbError.message}`);
+                                    }
+                                }
+                            }
+                            else {
+                                this.logger.warn(`[Zalo ${mode}] Could not fetch complete account info for ${instanceKey}.`);
+                            }
+                        }
+                        catch (error) {
+                            this.logger.error(`[Zalo ${mode}] Failed to fetch account info: ${error.message}`);
+                        }
+                        apiInstances.set(instanceKey, api);
+						// The context object will be stored with the API instance
+                        const context = {
+                            instanceKey,
+                            workflowId: this.getWorkflow().id,
+                            credentialName: currentName,
+                            credentialPhone: currentPhone,
+                            credentialUserId: currentUserId,
+                            eventTypes: this.getNodeParameter('eventTypes', 0),
+                            threadIdFiltering: this.getNodeParameter('threadIdFiltering', 0, false),
+                            keywordFiltering: this.getNodeParameter('keywordFiltering', 0, false),
+                            ignoreSelfEvents: this.getNodeParameter('ignoreSelfEvents', 0, true),
+                            listenOnlyThreads: (this.getNodeParameter('listenOnlyThreads', 0, '') || '').split(',')
+                                .map(id => id.trim())
+                                .filter(id => id),
+                            ignoreThreads: (this.getNodeParameter('ignoreThreads', 0, '') || '').split(',')
+                                .map(id => id.trim())
+                                .filter(id => id),
+                            listenOnlyKeywords: (this.getNodeParameter('listenOnlyKeywords', 0, '') || '').split(',')
+                                .map(keyword => keyword.trim().toLowerCase())
+                                .filter(keyword => keyword && keyword.length > 1),  // single-character
+                            ignoreKeywords: (this.getNodeParameter('ignoreKeywords', 0, '') || '').split(',')
+                                .map(keyword => keyword.trim().toLowerCase())
+                                .filter(keyword => keyword && keyword.length > 1),  // single-character
+                            webhookUrl: webhookUrl,
+                            logger: this.logger,
+                            helpers: this.helpers,
+                            getWorkflowStaticData: this.getWorkflowStaticData.bind(this),
+                            mode,
+                        };
+
+						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';
+
+                                if (context.threadIdFiltering) {
+                                    if (context.listenOnlyThreads.length > 0 && !context.listenOnlyThreads.includes(message.threadId)) {
+                                        context.logger.info(`[zalo listen] ${context.instanceKey} threadId: ${message.threadId} (not in listen-only list)`);
+                                        return;
+                                    }
+                                    if (context.ignoreThreads.length > 0 && context.ignoreThreads.includes(message.threadId)) {
+                                        context.logger.info(`[zalo listen] ${context.instanceKey} threadId : ${message.threadId} (in ignore list)`);
+                                        return;
+                                    }
+                                }
+                                if (context.keywordFiltering && (context.listenOnlyKeywords.length > 0 || context.ignoreKeywords.length > 0)) {
+                                    let messageText = '';
+                                    if (typeof message.data.content === 'string') {
+                                        messageText = message.data.content;
+                                    } else if (typeof message.data.content === 'object' && message.data.content !== null) {
+                                        try {
+                                            const parsedContent = JSON.parse(message.data.content);
+                                            if (typeof parsedContent.title === 'string') {
+                                                messageText = parsedContent.title;
+                                            }
+                                        } catch (e) {
+                                            if (typeof message.data.content.title === 'string') { // Direct object check
+                                                messageText = message.data.content.title;
+                                            }
+                                        }
+                                    }
+                                    const lowerCaseMessageText = messageText.toLowerCase();
+                                    if (context.listenOnlyKeywords.length > 0 && !context.listenOnlyKeywords.some(keyword => lowerCaseMessageText.includes(keyword))) {
+                                        context.logger.info(`[zalo listen] ${context.instanceKey} keyword: ${lowerCaseMessageText} in ${message.threadId} ignored (no listen-only keyword found)`);
+                                        return;
+                                    }
+                                    if (context.ignoreKeywords.length > 0 && context.ignoreKeywords.some(keyword => lowerCaseMessageText.includes(keyword))) {
+                                        context.logger.info(`[zalo listen] ${context.instanceKey} keyword: ${lowerCaseMessageText} in ${message.threadId} ignored (ignore keyword found)`);
+                                        return;
+                                    }
+                                }
+                                if (context.eventTypes.includes(eventType)) {
+                                    await handleEvent(context, message, eventType);
+                                }
+                            });
+                        }
+                        if (context.eventTypes.includes('reaction')) {
+                            api.listener.on('reaction', async (reaction) => {
+                                if (context.ignoreSelfEvents && reaction.isSelf) {
+                                    return;
+                                }
+                                await handleEvent(context, reaction, 'reaction');
+                            });
+                        }
+                        if (context.eventTypes.includes('undo')) {
+                            api.listener.on('undo', async (undo) => {
+                                if (context.ignoreSelfEvents && undo.isSelf) {
+                                    return;
+                                }
+                                await handleEvent(context, undo, 'undo');
+                            });
+                        }
+                        if (context.eventTypes.includes('group_event')) {
+                            api.listener.on('group_event', async (groupEvent) => {
+                                if (context.ignoreSelfEvents && groupEvent.isSelf) {
+                                    return;
+                                }
+                                await handleEvent(context, groupEvent, 'group_event');
+                            });
+                        }
+                        if (context.eventTypes.includes('friend_request')) {
+                            api.listener.on('friend_event', async (friendEvent) => {
+                                if (context.ignoreSelfEvents && friendEvent.isSelf) {
+                                    return;
+                                }
+                                await handleEvent(context, friendEvent, 'friend_request');
+                            });
+                        }
+                        async function handleEvent(context, data, eventType) {
+                            if (!data.isSelf) {
+                                context.logger.info(`[Zalo ${context.mode} received] ${context.credentialPhone}: ${eventType}`);
+                            }
+
+                            const dataWithContext = {
+                                ...data,
+                                _timestamp: new Date().toISOString(),
+                                _instanceKey: context.instanceKey,
+                                _name: context.credentialName,
+                                _phone: context.credentialPhone,
+                                _user_id: context.credentialUserId,
+                                _eventType: eventType,
+                                _source: 'zalo_trigger'
+                            };
+                            try {
+                                await context.helpers.httpRequest({
+                                    method: 'POST',
+                                    url: context.webhookUrl,
+                                    body: {
+                                        message: dataWithContext,
+                                        instanceKey: context.instanceKey,
+                                        trigger: 'zalo_trigger'
+                                    },
+                                    headers: {
+                                        'Content-Type': 'application/json',
+                                    },
+                                });
+                            }
+                            catch (webhookError) {
+                                const queue = messageQueue.get(context.instanceKey) || [];
+                                queue.push(dataWithContext);
+                                messageQueue.set(context.instanceKey, queue);
+                                context.logger.error(`Failed to trigger webhook for ${context.instanceKey}: ${webhookError.message} >> Event stored in fallback queue for ${context.instanceKey}, queue size: ${queue.length}`);
+                            }
+                            const webhookData = context.getWorkflowStaticData('node');
+                            if (!webhookData[context.instanceKey]) {
+                                webhookData[context.instanceKey] = {};
+                            }
+                            const instanceData = webhookData[context.instanceKey];
+                            instanceData.lastMessage = data;
+                            instanceData.lastMessageTime = new Date().toISOString();
+                        }
+
+                        api.listener.start();
+                        this.logger.info(`[Zalo ${mode}] [${apiInstances.size}] Started Listening: ${currentPhone} - ${currentName} (${context.eventTypes})`);
+                        const webhookData = this.getWorkflowStaticData('node');
+                        if (!webhookData[instanceKey]) {
+                            webhookData[instanceKey] = {};
+                        }
+                        const instanceData = webhookData[instanceKey];
+                        instanceData.isConnected = true;
+                        instanceData.eventTypes = this.getNodeParameter('eventTypes', 0);
+                        instanceData.createdAt = new Date().toISOString();
+                        return true;
+                    }
+                    catch (error) {
+                        const continueOnFail = this.getNodeParameter('continueOnFail', 0, false);
+                        if (continueOnFail) {
+                            this.logger.error(`Zalo connection failed: ${currentPhone}. Skipping trigger. Error: ${error.message}`);
+                            const tokenOverride = this.getNodeParameter('telegramTokenOverride', 0, '');
+                            const chatIdOverride = this.getNodeParameter('telegramChatIdOverride', 0, '');
+                            const telegramToken = tokenOverride || credentials.telegramToken;
+                            const telegramChatId = chatIdOverride || credentials.telegramChatId;
+
+                            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}`));
+                            }
+                            return false; // allow workflow to continue
+                        }
+                        // stop workflow active
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Zalo connection failed: ${error.message}`);
+                    }
+                },
+                async delete() {
+                    // this.getMode() === 'internal'
+                    const credentials = await this.getCredentials('zaloApi');
+                    const useSession = this.getNodeParameter('useSession', 0, false);
+                    const keyId = useSession ? this.getNodeParameter('connectToId', 0, '') : (credentials ? credentials.userId : '');
+                    const webhookUrl = this.getNodeWebhookUrl('default');
+                    const instanceKey = webhookUrl?.includes('/webhook-test/')
+                        ? `${keyId}-test`
+                        : `${keyId}`;
+
+					if (apiInstances.has(instanceKey)) {
+                        const api = apiInstances.get(instanceKey);
+                        if (api) {
+                            api.listener.stop();
+                            apiInstances.delete(instanceKey);
+                            this.logger.info(`[Zalo Trigger Deactivated] Stopped and deleted instance: ${instanceKey}`);
+                        }
+                    }
+                    if (reconnectTimers.has(instanceKey)) {
+                        clearTimeout(reconnectTimers.get(instanceKey));
+                        reconnectTimers.delete(instanceKey);
+                    }
+                    if (messageQueue.has(instanceKey)) {
+                        messageQueue.delete(instanceKey);
+                    }
+					const webhookData = this.getWorkflowStaticData('node');
+                    if (webhookData[instanceKey]) {
+                        delete webhookData[instanceKey];
+                    }
+                    return true;
+                },
+            },
+        };
+    }
+    async webhook() {
+        const req = this.getRequestObject();
+        const body = req.body;
+        const webhookData = this.getWorkflowStaticData('node');
+        const allMessages = [];
+        if (body && body.message && body.trigger === 'zalo_trigger') {
+            allMessages.push(body.message);
+        }
+        else {
+            for (const [instanceKey, messages] of messageQueue.entries()) {
+                this.logger.info(`Processing fallback queued messages for instance: ${instanceKey}, message count: ${messages.length}`);
+                if (messages.length > 0) {
+                    for (const message of messages) {
+                        allMessages.push(message);
+                        this.logger.info(`Added fallback queued message from ${instanceKey}`);
+                    }
+                    messageQueue.set(instanceKey, []);
+                    this.logger.info(`Cleared fallback message queue for ${instanceKey}`);
+                }
+            }
+        }
+        if (allMessages.length === 0) {
+            this.logger.info('No messages found, returning empty trigger data');
+            allMessages.push({
+                _trigger: 'empty',
+                _timestamp: new Date().toISOString(),
+                _source: 'zalo_trigger',
+                _debug: {
+                    webhookDataKeys: Object.keys(webhookData),
+                    messageQueueSize: messageQueue.size,
+                    messageQueueKeys: Array.from(messageQueue.keys()),
+                    requestBody: body
+                }
+            });
+        }
+        return {
+            workflowData: [this.helpers.returnJsonArray(allMessages)],
+        };
+    }
+}
+exports.ZaloTrigger = ZaloTrigger;