n8n-nodes-zalo-custom 1.0.0

package/nodes/ZaloUploadAttachment/ZaloUploadAttachment.node.js

@@ -0,0 +1,265 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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 fs_1 = __importDefault(require("fs"));
+let api;
+class ZaloUploadAttachment {
+    constructor() {
+        this.description = {
+            displayName: 'Zalo Upload Attachment',
+            name: 'zaloUploadAttachment',
+            icon: 'file:../shared/zalo.svg',
+            group: ['Zalo'],
+            version: 1,
+            description: 'Upload file đính kèm lên Zalo để lấy thông tin file (photoId, fileId, fileUrl...)',
+            defaults: {
+                name: 'Zalo Upload Attachment',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'zaloApi',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Thread ID',
+                    name: 'threadId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    description: 'ID của thread (user ID hoặc group ID) để upload file',
+                },
+                {
+                    displayName: 'Thread Type',
+                    name: 'threadType',
+                    type: 'options',
+                    options: [
+                        {
+                            name: 'User',
+                            value: 'user',
+                        },
+                        {
+                            name: 'Group',
+                            value: 'group',
+                        },
+                    ],
+                    default: 'user',
+                    description: 'Loại thread (user hoặc group)',
+                },
+                {
+                    displayName: 'Upload Sources',
+                    name: 'sources',
+                    type: 'fixedCollection',
+                    typeOptions: {
+                        multipleValues: true,
+                    },
+                    placeholder: 'Add Source',
+                    default: {},
+                    options: [
+                        {
+                            name: 'source',
+                            displayName: 'Source',
+                            values: [
+                                {
+                                    displayName: 'Source Type',
+                                    name: 'type',
+                                    type: 'options',
+                                    options: [
+                                        {
+                                            name: 'File Path',
+                                            value: 'filePath',
+                                        },
+                                        {
+                                            name: 'File URL',
+                                            value: 'fileUrl',
+                                        },
+                                        {
+                                            name: 'Binary Data',
+                                            value: 'binaryData',
+                                        },
+                                    ],
+                                    default: 'filePath',
+                                    description: 'Loại nguồn file để upload',
+                                },
+                                {
+                                    displayName: 'File Path',
+                                    name: 'filePath',
+                                    type: 'string',
+                                    default: '',
+                                    displayOptions: {
+                                        show: {
+                                            'type': ['filePath'],
+                                        },
+                                    },
+                                    description: 'Đường dẫn đến file cần upload',
+                                },
+                                {
+                                    displayName: 'File URL',
+                                    name: 'fileUrl',
+                                    type: 'string',
+                                    default: '',
+                                    displayOptions: {
+                                        show: {
+                                            'type': ['fileUrl'],
+                                        },
+                                    },
+                                    description: 'URL của file cần upload',
+                                },
+                                {
+                                    displayName: 'Binary Property',
+                                    name: 'binaryProperty',
+                                    type: 'string',
+                                    default: 'data',
+                                    displayOptions: {
+                                        show: {
+                                            'type': ['binaryData'],
+                                        },
+                                    },
+                                    description: 'Tên của binary property chứa file data',
+                                },
+                                {
+                                    displayName: 'File Name',
+                                    name: 'fileName',
+                                    type: 'string',
+                                    default: '',
+                                    displayOptions: {
+                                        show: {
+                                            'type': ['binaryData'],
+                                        },
+                                    },
+                                    description: 'Tên file (bắt buộc khi sử dụng binary data)',
+                                },
+                            ],
+                        },
+                    ],
+                    description: 'Danh sách các file cần upload',
+                },
+            ],
+        };
+    }
+    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
+            });
+            if (!api) {
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to initialize Zalo API. Check your credentials.');
+            }
+        }
+        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);
+                const threadTypeStr = this.getNodeParameter('threadType', i);
+                const threadType = threadTypeStr === 'user' ? zca_js_1.ThreadType.User : zca_js_1.ThreadType.Group;
+                const sourcesData = this.getNodeParameter('sources', i, {});
+                if (!sourcesData.source || sourcesData.source.length === 0) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Cần ít nhất một file để upload');
+                }
+                const sources = [];
+                const tempFiles = [];
+                for (const sourceConfig of sourcesData.source) {
+                    let source;
+                    if (sourceConfig.type === 'filePath') {
+                        const 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}`);
+                        }
+                        source = filePath;
+                    }
+                    else if (sourceConfig.type === 'fileUrl') {
+                        const fileUrl = sourceConfig.fileUrl;
+                        const tempFilePath = await (0, helper_1.saveFile)(fileUrl);
+                        if (!tempFilePath) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Không thể tải file từ URL: ${fileUrl}`);
+                        }
+                        tempFiles.push(tempFilePath);
+                        source = tempFilePath;
+                    }
+                    else if (sourceConfig.type === 'binaryData') {
+                        const binaryProperty = sourceConfig.binaryProperty;
+                        const fileName = sourceConfig.fileName;
+                        if (!fileName) {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'File name là bắt buộc khi sử dụng binary data');
+                        }
+                        this.helpers.assertBinaryData(i, binaryProperty);
+                        const buffer = await this.helpers.getBinaryDataBuffer(i, binaryProperty);
+                        source = {
+                            data: buffer,
+                            filename: fileName,
+                            metadata: {
+                                fileName: fileName,
+                                totalSize: buffer.length,
+                            }
+                        };
+                    }
+                    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);
+                }
+                this.logger.info(`Successfully uploaded ${uploadResults.length} file(s)`);
+                returnData.push({
+                    json: {
+                        success: true,
+                        threadId,
+                        threadType: threadTypeStr,
+                        uploadResults,
+                        totalFiles: uploadResults.length,
+                    },
+                });
+            }
+            catch (error) {
+                this.logger.error('Error uploading attachments:', 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.ZaloUploadAttachment = ZaloUploadAttachment;

package/nodes/ZaloUploadAttachment/ZaloUploadAttachmentDescription.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZaloUploadAttachmentDescription = void 0;
+exports.ZaloUploadAttachmentDescription = {
+    displayName: 'Zalo Upload Attachment',
+    name: 'zaloUploadAttachment',
+    icon: 'file:../shared/zalo.svg',
+    group: ['Zalo'],
+    version: 1,
+    description: 'Upload attachment (ảnh, video, file) lên Zalo sử dụng kết nối đăng nhập bằng cookie',
+    defaults: {
+        name: 'Zalo Upload Attachment',
+    },
+    inputs: ['main'],
+    outputs: ['main'],
+    credentials: [
+        {
+            name: 'zaloApi',
+            required: true,
+        },
+    ],
+    properties: [
+        {
+            displayName: 'Thread ID',
+            name: 'threadId',
+            type: 'string',
+            default: '',
+            required: true,
+            description: 'ID của thread để upload attachment (User ID hoặc Group ID)',
+        },
+        {
+            displayName: 'Type',
+            name: 'type',
+            type: 'options',
+            options: [
+                {
+                    name: 'User',
+                    value: 0,
+                },
+                {
+                    name: 'Group',
+                    value: 1,
+                },
+            ],
+            default: 0,
+            description: 'Loại của thread (user hoặc group)',
+        },
+        {
+            displayName: 'Attachment Source',
+            name: 'attachmentSource',
+            type: 'options',
+            options: [
+                {
+                    name: 'File Path',
+                    value: 'filePath',
+                    description: 'Đường dẫn file trên server n8n',
+                },
+                {
+                    name: 'URL',
+                    value: 'url',
+                    description: 'URL công khai của file',
+                },
+                {
+                    name: 'Binary Data',
+                    value: 'binary',
+                    description: 'Binary data từ n8n workflow',
+                },
+            ],
+            default: 'filePath',
+            description: 'Nguồn của attachment',
+        },
+        {
+            displayName: 'File Path',
+            name: 'filePath',
+            type: 'string',
+            default: '',
+            displayOptions: {
+                show: {
+                    attachmentSource: ['filePath'],
+                },
+            },
+            description: 'Đường dẫn tuyệt đối đến file trên server n8n',
+            placeholder: '/path/to/your/file.jpg',
+        },
+        {
+            displayName: 'File URL',
+            name: 'fileUrl',
+            type: 'string',
+            default: '',
+            displayOptions: {
+                show: {
+                    attachmentSource: ['url'],
+                },
+            },
+            description: 'URL công khai của file cần upload',
+            placeholder: 'https://example.com/image.jpg',
+        },
+        {
+            displayName: 'Binary Property',
+            name: 'binaryProperty',
+            type: 'string',
+            default: 'data',
+            displayOptions: {
+                show: {
+                    attachmentSource: ['binary'],
+                },
+            },
+            description: 'Tên của binary property chứa file data',
+        },
+        {
+            displayName: 'Filename',
+            name: 'filename',
+            type: 'string',
+            default: '',
+            displayOptions: {
+                show: {
+                    attachmentSource: ['binary'],
+                },
+            },
+            description: 'Tên file với extension (ví dụ: image.jpg, document.pdf)',
+            placeholder: 'image.jpg',
+        },
+        {
+            displayName: 'Multiple Files',
+            name: 'multipleFiles',
+            type: 'boolean',
+            default: false,
+            description: 'Upload nhiều file cùng lúc',
+        },
+        {
+            displayName: 'File Paths (Multiple)',
+            name: 'filePaths',
+            type: 'string',
+            default: '',
+            displayOptions: {
+                show: {
+                    attachmentSource: ['filePath'],
+                    multipleFiles: [true],
+                },
+            },
+            description: 'Danh sách đường dẫn file cách nhau bởi dấu phẩy hoặc xuống dòng',
+            placeholder: '/path/to/file1.jpg\n/path/to/file2.pdf\n/path/to/file3.mp4',
+        },
+        {
+            displayName: 'File URLs (Multiple)',
+            name: 'fileUrls',
+            type: 'string',
+            default: '',
+            displayOptions: {
+                show: {
+                    attachmentSource: ['url'],
+                    multipleFiles: [true],
+                },
+            },
+            description: 'Danh sách URL file cách nhau bởi dấu phẩy hoặc xuống dòng',
+            placeholder: 'https://example.com/file1.jpg\nhttps://example.com/file2.pdf',
+        },
+        {
+            displayName: 'Binary Properties (Multiple)',
+            name: 'binaryProperties',
+            type: 'string',
+            default: '',
+            displayOptions: {
+                show: {
+                    attachmentSource: ['binary'],
+                    multipleFiles: [true],
+                },
+            },
+            description: 'Tên các binary properties cách nhau bởi dấu phẩy',
+            placeholder: 'data1,data2,data3',
+        },
+        {
+            displayName: 'Filenames (Multiple)',
+            name: 'filenames',
+            type: 'string',
+            default: '',
+            displayOptions: {
+                show: {
+                    attachmentSource: ['binary'],
+                    multipleFiles: [true],
+                },
+            },
+            description: 'Tên các file với extension cách nhau bởi dấu phẩy',
+            placeholder: 'file1.jpg,file2.pdf,file3.mp4',
+        },
+    ],
+};

package/nodes/ZaloUser/ZaloUser.node.js

@@ -0,0 +1,212 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZaloUser = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const ZaloNodeProperties_1 = require("../shared/ZaloNodeProperties");
+const ZaloUserDescription_1 = require("./ZaloUserDescription");
+const zalo_helper_1 = require("../utils/zalo.helper");
+let api;
+class ZaloUser {
+    constructor() {
+        this.description = {
+            displayName: 'Zalo User',
+            name: 'zaloUser',
+            icon: 'file:../shared/zalo.svg',
+            group: ['Zalo'],
+            version: 1,
+            subtitle: '={{$parameter["resource"] + ": " + $parameter["operation"]}}',
+            description: 'Quản lý người dùng Zalo',
+            defaults: {
+                name: 'Zalo User',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [...ZaloNodeProperties_1.zaloApiCredential],
+            properties: [
+                ...ZaloNodeProperties_1.zaloSessionProperties,
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Zalo User',
+                            value: 'zaloUser',
+                        },
+                    ],
+                    default: 'zaloUser',
+                },
+                ...ZaloUserDescription_1.zaloUserOperations,
+                ...ZaloUserDescription_1.zaloUserFields,
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+
+        api = await (0, zalo_helper_1.getZaloApiClient)(this, {});
+        if (!api) {
+            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Failed to initialize Zalo API. Check credentials or User ID.');
+        }
+
+        for (let i = 0; i < items.length; i++) {
+            try {
+                const resource = this.getNodeParameter('resource', i);
+                const operation = this.getNodeParameter('operation', i);
+                if (resource === 'zaloUser') {
+					switch (operation) {
+						case 'acceptFriendRequest': {
+							const userId = this.getNodeParameter('userId', i);
+							const response = await api.acceptFriendRequest(userId);
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'rejectFriendRequest': {
+							const userId = this.getNodeParameter('userId', i);
+							const response = await api.rejectFriendRequest(userId);
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'removeFriend': {
+							const userId = this.getNodeParameter('userId', i);
+							const response = await api.removeFriend(userId);
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'getFriendRecommendations': {
+							const response = await api.getFriendRecommendations();
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'sendFriendRequest': {
+							const userId = this.getNodeParameter('userId', i);
+							const message = this.getNodeParameter('message', i);
+							const response = await api.sendFriendRequest(message, userId);
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'blockUser': {
+							const userId = this.getNodeParameter('userId', i);
+							const response = await api.blockUser(userId);
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'unblockUser': {
+							const userId = this.getNodeParameter('userId', i);
+							const response = await api.unblockUser(userId);
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'updateProfile': {
+							const name = this.getNodeParameter('name', i);
+							const dob = this.getNodeParameter('dob', i);
+							const gender = this.getNodeParameter('gender', i);
+							const response = await api.updateProfile(name, dob, gender);
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'getUserInfo': {
+							const userId = this.getNodeParameter('userId', i);
+							const response = await api.getUserInfo(userId);
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'getAllFriends': {
+							const response = await api.getAllFriends();
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'findUser': {
+							const phoneNumber = this.getNodeParameter('phoneNumber', i);
+							const response = await api.findUser(phoneNumber);
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'changeAliasName': {
+							const userId = this.getNodeParameter('userId', i);
+							const aliasName = this.getNodeParameter('aliasName', i);
+							const response = await api.changeFriendAlias(aliasName, userId);
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'undoMessage': {
+							const threadId = this.getNodeParameter('threadId', i);
+							const type = this.getNodeParameter('threadType', i);
+							const msgId = this.getNodeParameter('msgId', i);
+							const cliMsgId = this.getNodeParameter('cliMsgId', i);
+							const UndoOptions = {
+								msgId: msgId,
+								cliMsgId: cliMsgId,
+							};
+							const response = await api.undo(UndoOptions, threadId, type);
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'removeUnreadMark': {
+							const threadId = this.getNodeParameter('threadId', i);
+							const type = this.getNodeParameter('threadType', i);
+							const response = await api.removeUnreadMark(threadId, type);
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'addUnreadMark': {
+							const threadId = this.getNodeParameter('threadId', i);
+							const type = this.getNodeParameter('threadType', i);
+							const response = await api.addUnreadMark(threadId, type);
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'undoFriendRequest': {
+							const userId = this.getNodeParameter('userId', i);
+							const response = await api.undoFriendRequest(userId);
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'getSentFriendRequest': {
+							const response = await api.getSentFriendRequest();
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'getQR': {
+							const userId = this.getNodeParameter('userId', i);
+							const response = await api.getQR(userId);
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'fetchAccountInfo': {
+							const response = await api.fetchAccountInfo();
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+						case 'getContext': {
+							const response = api.getContext();
+							returnData.push({ json: { success: true, response }, pairedItem: { item: i } });
+							break;
+						}
+					}
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: {
+                            success: false,
+                            error: error.message,
+                        },
+                        pairedItem: {
+                            item: i,
+                        },
+                    });
+                    continue;
+                }
+                throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, {
+                    itemIndex: i,
+                });
+            }
+        }
+        return [returnData];
+    }
+}
+exports.ZaloUser = ZaloUser;