n8n-nodes-zalo-custom 1.0.0

package/nodes/ZaloLoginByQr/ZaloLoginByQr.node.js

@@ -0,0 +1,579 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZaloLoginByQr = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const zca_js_1 = require("zca-js");
+const path = __importStar(require("path"));
+const zalo_helper_1 = require("../utils/zalo.helper");
+const crypto_helper_1 = require("../utils/crypto.helper");
+const axios_1 = __importDefault(require("axios"));
+
+class ZaloLoginByQr {
+    constructor() {
+        this.description = {
+            displayName: 'Zalo Login By QR',
+            name: 'zaloLoginByQr',
+            group: ['Zalo'],
+            version: 1,
+            description: 'Đăng nhập Zalo bằng QR code và lưu thông tin vào Credential',
+            defaults: {
+                name: 'Zalo Login QR',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            icon: 'file:../shared/zalo.svg',
+            credentials: [
+                {
+                    name: 'n8nZaloApi',
+                    required: true,
+                    displayName: 'n8n Account Credential',
+                    description: 'Get "n8n API" from settings then create: "n8n Zalo API Credential"\n',
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Proxy',
+                    name: 'proxy',
+                    type: 'string',
+                    default: '',
+                    placeholder: 'https://user:pass@host:port',
+                    description: 'HTTP proxy to use for Zalo API requests',
+                },
+                // {
+                //     displayName: 'Delete Zalo Credential Duplicate UserId',
+                //     name: 'deleteOldZaloApi',
+                //     type: 'boolean',
+                //     default: false,
+                //     description: 'Delete old zalo credential if exists',
+                // },
+                {
+                    displayName: 'Notifications to Telegram',
+                    name: 'sendToTelegram',
+                    type: 'boolean',
+                    default: false,
+                    description: 'Whether to send QR code and status updates to a Telegram chat',
+                },
+                {
+                    displayName: 'Bot Token',
+                    name: 'telegramToken',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    displayOptions: {
+                        show: { sendToTelegram: [true] },
+                    },
+                    description: 'The token for your Telegram bot',
+                },
+                {
+                    displayName: 'Chat ID',
+                    name: 'telegramChatId',
+                    type: 'string',
+                    required: true,
+                    default: '',
+                    displayOptions: {
+                        show: { sendToTelegram: [true] },
+                    },
+                    description: 'Telegram chat_id to send notifications to',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const returnData = [];
+        let proxy = this.getNodeParameter('proxy', 0, '');
+        if (proxy && !proxy.toLowerCase().startsWith('http')) {
+            this.logger.warn(`Proxy không hợp lệ: "${proxy}"`);
+            proxy = '';
+        }
+        const timeout = 30;
+        const fileName = 'zalo-qr-code.png';
+        const deleteOldZaloApi = this.getNodeParameter('deleteOldZaloApi', 0, false);  // bỏ vì xoá xong gây ra lỗi k lưu được
+        const sendToTelegram = this.getNodeParameter('sendToTelegram', 0, false);
+        const telegramToken = this.getNodeParameter('telegramToken', 0, '');
+        const telegramChatId = this.getNodeParameter('telegramChatId', 0, '');
+
+        const telegramOptions = {
+            token: telegramToken,
+            chatId: telegramChatId,
+            logger: this.logger,
+        };
+        let n8nCredential;
+        try {
+            n8nCredential = await this.getCredentials('n8nZaloApi');
+        }
+        catch (error) {
+        }
+        const selectedCredential = n8nCredential;
+        if (selectedCredential) {
+            this.logger.info('Using n8n account credential');
+        }
+        else {
+            this.logger.info('No credentials provided, will generate QR code for login');
+        }
+        try {
+            const zaloOptions = {
+                selfListen: true,
+                logging: true,
+            };
+            if (proxy) {
+                zaloOptions.proxy = proxy;
+            }
+            let zalo;
+            if (selectedCredential) {
+                this.logger.info('Using existing Zalo credentials');
+                zalo = new zca_js_1.Zalo(zaloOptions);
+                this.logger.info('Using n8n credential to get Zalo credentials');
+                const n8nApiKey = selectedCredential.apiKey;
+                const n8nUrl = selectedCredential.url || 'http://localhost:5678';
+                this.logger.info(`Using n8n API at ${n8nUrl} with API key ${n8nApiKey ? 'provided' : 'not provided'}`);
+                this.logger.info('n8n credential support is not fully implemented yet. Will use QR code login.');
+                zalo = new zca_js_1.Zalo(zaloOptions);
+            }
+            else {
+                zalo = new zca_js_1.Zalo(zaloOptions);
+            }
+            this.logger.info('Starting Zalo QR login process...');
+            let userDisplayName = '';
+            let userAvatar = '';
+            let userImei = '';
+            let userUserAgent = '';
+            let userZaloUserId = '';
+            let createdCredentialId = '';
+            const processContext = (context) => {
+                if (!context) {
+                    this.logger.warn('Context is null or undefined');
+                    return;
+                }
+                const cookie = context.cookie || '';
+                const imei = context.imei || '';
+                const userAgent = context.userAgent || '';
+                const zaloUserId = context.userId || context.zaloUserId || '';
+                userImei = imei;
+                userUserAgent = userAgent;
+                userZaloUserId = zaloUserId;
+                this.logger.info('=== ZALO CREDENTIALS ===');
+                this.logger.info(`Cookie: ${cookie ? `Received (length: ${typeof cookie === 'string' ? cookie.length : (Array.isArray(cookie) ? cookie.length : 'unknown')})` : 'None'}`);
+                this.logger.info(`IMEI: ${imei ? imei : 'None'}`);
+                this.logger.info(`User Agent: ${userAgent ? userAgent : 'None'}`);
+                this.logger.info(`Zalo User ID: ${zaloUserId ? zaloUserId : 'None'}`);
+                this.logger.info('=== END CREDENTIALS ===');
+            };
+            const setupEventListeners = (api) => {
+                this.logger.info('Setting up event listeners to get credentials');
+                try {
+                    if (typeof api.getContext === 'function') {
+                        const contextResult = api.getContext();
+                        if (contextResult && typeof contextResult.then === 'function') {
+                            contextResult.then((context) => {
+                                processContext(context);
+                            }).catch((error) => {
+                                this.logger.error(`Error getting context: ${error.message}`);
+                            });
+                        }
+                        else {
+                            processContext(contextResult);
+                        }
+                    }
+                    else {
+                        this.logger.warn('getContext is not a function');
+                        if (api.context) {
+                            this.logger.info('Found context in api object');
+                            processContext(api.context);
+                        }
+                        else {
+                            this.logger.warn('No context found in api object');
+                        }
+                    }
+                }
+                catch (error) {
+                    this.logger.error(`Error in setupEventListeners: ${error.message}`);
+                }
+            };
+            const qrCodePromise = new Promise(async (resolve, reject) => {
+                let isResolved = false;
+                let api = null;
+                const timeoutId = setTimeout(() => {
+                    if (!isResolved) {
+                        isResolved = true;
+                        const timeoutError = new n8n_workflow_1.NodeOperationError(this.getNode(), 'Timeout generating QR code. Please try again or check your Zalo connection.');
+                        if (sendToTelegram) {
+                            (0, zalo_helper_1.sendToTelegram)({
+                                ...telegramOptions,
+                                text: `❌ Đã hết thời gian chờ tạo mã QR Zalo. Vui lòng thử lại.`,
+                            }).catch(e => this.logger.error(`Không thể gửi thông báo timeout đến Telegram: ${e.message}`));
+                        }
+                        reject(timeoutError);
+                    }
+                }, timeout * 1000);
+                try {
+                    api = await zalo.loginQR(null, (qrEvent) => {
+                        var _a, _b, _c;
+                        this.logger.info(`Received QR event type: ${qrEvent ? qrEvent.type : 'no event'}`);
+                        switch (qrEvent.type) {
+                            case 0:
+                                if ((_a = qrEvent === null || qrEvent === void 0 ? void 0 : qrEvent.data) === null || _a === void 0 ? void 0 : _a.image) {
+                                    const qrCodeBase64 = qrEvent.data.image;
+                                    this.logger.info(`QR code generated, length: ${qrCodeBase64.length}`);
+                                    if (isResolved)
+                                        return;
+                                    clearTimeout(timeoutId);
+                                    if (qrCodeBase64) {
+                                        isResolved = true;
+                                        resolve(qrCodeBase64);
+                                    }
+                                }
+                                else {
+                                    console.log('Could not get QR code from Zalo SDK');
+                                    reject(new Error("Could not get QR code"));
+                                }
+                                break;
+                            case 1:
+                                if (sendToTelegram) {
+                                    (0, zalo_helper_1.sendToTelegram)({
+                                        ...telegramOptions,
+                                        text: `❌ Đã hết thời gian chờ tạo mã QR Zalo. Vui lòng thử lại.`,
+                                    }).catch(e => this.logger.error(`Không thể gửi thông báo timeout đến Telegram: ${e.message}`));
+                                }
+                                this.logger.warn('QR code expired. Please try again.');
+                                break; // This event often precedes a timeout error, so a log is sufficient.
+                            case 2:
+                                this.logger.info('=== QR CODE SCANNED ===');
+                                if (qrEvent === null || qrEvent === void 0 ? void 0 : qrEvent.data) {
+                                    userDisplayName = qrEvent.data.display_name || '';
+                                    userAvatar = qrEvent.data.avatar || '';
+                                    this.logger.info(`User: ${userDisplayName}`);
+                                    this.logger.info(`Avatar: ${userAvatar ? 'Yes' : 'No'}`);
+                                }
+                                break;
+                            case 3:
+                                this.logger.warn('=== QR CODE DECLINED ===');
+                                if ((_b = qrEvent === null || qrEvent === void 0 ? void 0 : qrEvent.data) === null || _b === void 0 ? void 0 : _b.code) {
+                                    this.logger.warn(`Decline code: ${qrEvent.data.code}`);
+                                    if (sendToTelegram) {
+                                        (0, zalo_helper_1.sendToTelegram)({
+                                            ...telegramOptions,
+                                            text: `⚠️ Người dùng đã từ chối đăng nhập Zalo.`,
+                                        }).catch(e => this.logger.error(`Không thể gửi thông báo từ chối đến Telegram: ${e.message}`));
+                                    }
+                                }
+                                break;
+                            case 4:
+                                this.logger.info('=== GOT LOGIN INFO ===');
+                                if (qrEvent === null || qrEvent === void 0 ? void 0 : qrEvent.data) {
+                                    const cookie = qrEvent.data.cookie || [];
+                                    const imei = qrEvent.data.imei || '';
+                                    const userAgent = qrEvent.data.userAgent || '';
+                                    const displayName = userDisplayName;
+                                    const avatar = userAvatar;
+
+                                    if (sendToTelegram) {
+                                        (0, zalo_helper_1.sendToTelegram)({
+                                            ...telegramOptions,
+                                            text: `${displayName}: đã xác nhận, tiến hành lưu trữ...`,
+                                        }).catch(e => this.logger.error(`Không thể gửi thông báo đăng nhập thành công đến Telegram: ${e.message}`));
+                                    }
+                                    if (cookie && cookie.length > 0 && imei && userAgent) {
+                                        // Use an async IIFE to handle the async login and subsequent actions
+                                        (async () => {
+                                            try {
+                                                this.logger.info('Login trực tiếp để lấy UID...');
+                                                const loginApi = await new zca_js_1.Zalo().login({ cookie, imei, userAgent });
+                                                const newInfo = await loginApi.fetchAccountInfo();
+                                                if (newInfo && newInfo.profile && newInfo.profile.userId) {
+                                                    userZaloUserId = newInfo.profile.userId;
+                                                    const rawPhoneNumber = newInfo.profile.phoneNumber || '';
+                                                    const zaloPhoneNumber = rawPhoneNumber.startsWith('+84')
+                                                        ? '0' + rawPhoneNumber.substring(3)
+                                                        : rawPhoneNumber;
+                                                    this.logger.info(`UID: ${userZaloUserId} - Phone: ${zaloPhoneNumber}`);
+
+                                                    const now = new Date();
+                                                    const time = now.toLocaleTimeString('en-GB', { hour: '2-digit', minute: '2-digit' });
+                                                    const date = now.toLocaleDateString('en-GB', { day: '2-digit', month: '2-digit' });  // year: '2-digit'
+                                                    const credentialName = `${zaloPhoneNumber} _ ${displayName} _ ${time} ${date}`;
+
+                                                    const credentialData = {
+                                                        cookie: JSON.stringify(cookie),
+                                                        imei: imei,
+                                                        userAgent: userAgent,
+                                                        proxy: proxy || '',
+                                                        nameAccount: displayName,
+                                                        userId: userZaloUserId,
+                                                        phoneNumber: zaloPhoneNumber,
+                                                        telegramToken: telegramToken,
+                                                        telegramChatId: telegramChatId,
+                                                        supportCode: '',
+                                                        licenseKey: ''
+                                                    };
+                                                    try {
+                                                        this.logger.info('Attempting to create Zalo credential via n8n API');
+                                                        const credentialApiData = {
+                                                            name: credentialName,
+                                                            type: 'zaloApi',
+                                                            nodesAccess: [],
+                                                            data: credentialData
+                                                        };
+                                                        const ports = [5678];
+                                                        const createCredentialOnPort = async (port) => {
+                                                            const n8nApi = await this.getCredentials('n8nZaloApi');
+                                                            const n8nApiUrl = n8nApi.url;
+                                                            const fullApiUrl = `${n8nApiUrl}/api/v1/credentials`;
+                                                            const n8nApiKey = n8nApi.apiKey;
+                                                            this.logger.info(`Trying to create credential via n8n API at ${fullApiUrl}`);
+                                                            try {
+                                                                const response = await axios_1.default.post(fullApiUrl, credentialApiData, {
+                                                                    headers: {
+                                                                        'Content-Type': 'application/json',
+                                                                        'X-N8N-API-KEY': n8nApiKey
+                                                                    },
+                                                                });
+                                                                this.logger.info('Credential created successfully via n8n API');
+                                                                if (response.data && response.data.id) {
+                                                                    this.logger.info(`Credential ID: ${response.data.id}`);
+                                                                    createdCredentialId = response.data.id;
+                                                                    let text_telegram = '';
+                                                                    try {
+                                                                        if (userZaloUserId && userZaloUserId !== 'unknown') {
+                                                                            const encryptionKey = userZaloUserId.repeat(3);
+                                                                            const sessionDataToEncrypt = { cookie, imei, userAgent };
+                                                                            const encryptedData = (0, crypto_helper_1.encrypt)(sessionDataToEncrypt, encryptionKey);
+                                                                            const sessionDetails = {
+                                                                                userId: userZaloUserId,
+                                                                                name: displayName,
+                                                                                phone: zaloPhoneNumber,
+                                                                                credentialId: createdCredentialId,
+                                                                                encryptedData: encryptedData,
+                                                                            };
+                                                                            const { oldCredentialId } = await (0, zalo_helper_1.saveOrUpdateSession)(sessionDetails);
+                                                                            this.logger.info(`Session for user ID "${userZaloUserId}" has been securely saved/updated in the database.`);
+                                                                            text_telegram += '\n- Lưu thông tin đăng nhập';
+                                                                            // Xoá nếu hiện có sẵn ID cũ
+                                                                            if (oldCredentialId) {
+                                                                                text_telegram += `\n- Hãy xoá crendentialId cũ: ${oldCredentialId}`;
+                                                                            }
+                                                                            if (deleteOldZaloApi && oldCredentialId) {
+                                                                                this.logger.info(`[Delete] Found old credential ID "${oldCredentialId}" for user "${userZaloUserId}". Attempting to delete.`);
+                                                                                const deleteUrl = `${n8nApiUrl}/api/v1/credentials/${oldCredentialId}`;
+                                                                                await axios_1.default.delete(deleteUrl, {
+                                                                                    headers: { 'X-N8N-API-KEY': n8nApiKey },
+                                                                                }).then(() => {
+                                                                                    this.logger.info(`[Delete] Successfully deleted old credential with ID: ${oldCredentialId}`);
+                                                                                    text_telegram += `\n- Xoá credential cũ: ${oldCredentialId}`;
+                                                                                }).catch(deleteError => {
+                                                                                    if (deleteError.response && deleteError.response.status === 404) {
+                                                                                        this.logger.warn(`[Delete] Old credential not found on n8n (404). It might have been deleted already.`);
+                                                                                    } else {
+                                                                                        this.logger.error(`[Delete] Failed to delete old credential: ${deleteError.message}`);
+                                                                                    }
+                                                                                });
+                                                                            }
+                                                                        }
+                                                                        else {
+                                                                            this.logger.warn(`Skipping session save because userZaloUserId is invalid: "${userZaloUserId}"`);
+                                                                        }
+                                                                    }
+                                                                    catch (fileError) {
+                                                                        this.logger.error(`Failed to save session to database: ${fileError.message}`);
+                                                                    }
+
+                                                                    if (sendToTelegram) {
+                                                                        (0, zalo_helper_1.sendToTelegram)({
+                                                                            ...telegramOptions,
+                                                                            text: `✅ Đăng nhập thành công\n- ${displayName}: ${zaloPhoneNumber}${text_telegram}`,
+                                                                        }).catch(e => this.logger.error(`Không thể gửi thông báo đăng nhập thành công đến Telegram: ${e.message}`));
+                                                                    }
+                                                                }
+                                                                return true;
+                                                            }
+                                                            catch (apiError) {
+                                                                this.logger.error(`Error creating credential on port ${port}: ${apiError.message}`);
+                                                                if (apiError.response) {
+                                                                    this.logger.error(`API Error Status: ${apiError.response.status}`);
+                                                                    this.logger.error(`API Error Data: ${JSON.stringify(apiError.response.data)}`);
+                                                                }
+                                                                return false;
+                                                            }
+                                                        };
+                                                        let credentialCreated = false;
+                                                        for (const port of ports) {
+                                                            try {
+                                                                const result = await createCredentialOnPort.call(this, port);
+                                                                if (result) {
+                                                                    credentialCreated = true;
+                                                                    break;
+                                                                }
+                                                            }
+                                                            catch (error) {
+                                                                this.logger.error(`Error trying port ${port}: ${error.message}`);
+                                                            }
+                                                        }
+                                                        if (!credentialCreated) {
+                                                            this.logger.warn('Could not create credential via n8n API on any port.');
+                                                            this.logger.info('Credential info saved to file. You can create it manually using:');
+                                                            this.logger.info('node auto-create-zalo-credential.js');
+                                                        }
+                                                    }
+                                                    catch (error) {
+                                                        this.logger.error(`Error creating credential: ${error.message}`);
+                                                        this.logger.info('Credential info saved to file. You can create it manually using:');
+                                                        this.logger.info('node auto-create-zalo-credential.js');
+                                                    }
+                                                } // End of if (newInfo...)
+                                                else {
+                                                    userZaloUserId = 'unknown';
+                                                    this.logger.warn('Login successful but could not get UID from fetchAccountInfo.');
+                                                }
+                                            }
+                                            catch (error) {
+                                                this.logger.warn(`Login error: ${error.message}`);
+                                                userZaloUserId = 'unknown';
+                                            }
+                                        })();
+                                    }
+                                    else {
+                                        userZaloUserId = 'unknown';
+                                    }
+                                }
+                                break;
+                            default:
+                                this.logger.warn(`Unknown QR event type: ${qrEvent.type}`);
+                                break;
+                        }
+                    });
+                    this.logger.info('Starting Zalo listener');
+                    api.listener.start();
+                    api.listener.onConnected(() => {
+                        this.logger.info("=== ZALO SDK CONNECTED ===");
+                        setupEventListeners(api);
+                    });
+                    api.listener.onError((error) => {
+                        this.logger.error("=== ZALO ERROR ===", error);
+                    });
+                    this.logger.info('All event listeners set up');
+                }
+                catch (error) {
+                    clearTimeout(timeoutId);
+                    if (!isResolved) {
+                        isResolved = true;
+                        reject(error);
+                    }
+                }
+            });
+            const qrCodeBase64 = await qrCodePromise;
+            const binaryData = Buffer.from(qrCodeBase64, 'base64');
+            if (sendToTelegram) {
+                await (0, zalo_helper_1.sendToTelegram)({
+                    ...telegramOptions,
+                    binaryData: binaryData,
+                    fileName: fileName,
+                    caption: 'Vui lòng quét mã QR này bằng ứng dụng Zalo để đăng nhập. Mã có hiệu lực trong khoảng 45 giây.',
+                });
+            }
+            const newItem = {
+                json: {
+                    success: true,
+                    state: '',
+                    message: selectedCredential
+                        ? 'Using n8n account credential. QR code generated successfully.'
+                        : 'QR code generated successfully. Scan with Zalo app to login.',
+                    fileName,
+                    usingExistingCredential: !!selectedCredential,
+                    credentialType: selectedCredential ? 'n8nZaloApi' : null,
+                    userInfo: {
+                        displayName: userDisplayName || 'Not available yet - scan QR code first',
+                        avatar: userAvatar || 'Not available yet - scan QR code first'
+                    },
+                    zaloApiInfo: {
+                        imei: userImei || 'Not available yet',
+                        userAgent: userUserAgent || 'Not available yet',
+                        zaloUserId: userZaloUserId || 'Not available yet'
+                    },
+                    webhook: {
+                        enabled: false
+                    },
+                    binary: {
+                        data: await this.helpers.prepareBinaryData(binaryData, fileName, 'image/png'),
+                    }
+                },
+                binary: {
+                    data: await this.helpers.prepareBinaryData(binaryData, fileName, 'image/png'),
+                },
+            };
+            returnData.push(newItem);
+            if (returnData[0] && returnData[0].json) {
+                if (!selectedCredential) {
+                    returnData[0].json.credentialInstructions = 'Credentials have been saved to file. Credentials will be created automatically if n8n API credentials are provided.';
+                    returnData[0].json.credentialFilePath = path.join(process.cwd(), 'output', 'zalo-credentials.json');
+                    returnData[0].json.autoCreateScript = 'node auto-create-zalo-credential.js';
+                    returnData[0].json.autoCreateApi = 'Credentials will be created automatically via n8n API if n8n API credentials are provided.';
+                    if (createdCredentialId) {
+                        returnData[0].json.createdCredentialId = createdCredentialId;
+                        returnData[0].json.credentialCreationStatus = 'success';
+                    }
+                }
+                else if (selectedCredential) {
+                    returnData[0].json.credentialInstructions = 'Using n8n account credential. New Zalo credentials will be created automatically after successful login.';
+                    returnData[0].json.credentialName = selectedCredential.name || 'Unknown';
+                    returnData[0].json.credentialId = selectedCredential.id || 'Unknown';
+                    returnData[0].json.credentialType = 'n8nZaloApi';
+                    returnData[0].json.autoCreateApi = 'Credentials will be created automatically via n8n API after successful login.';
+                    if (createdCredentialId) {
+                        returnData[0].json.createdCredentialId = createdCredentialId;
+                        returnData[0].json.credentialCreationStatus = 'success';
+                    }
+                }
+            }
+            return [returnData];
+        }
+        catch (error) {
+            if (this.continueOnFail()) {
+                const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray({
+                    error: error.message,
+                    state: '',
+                    success: false
+                }), { itemData: { item: 0 } });
+                return [executionData];
+            }
+            else {
+                throw error;
+            }
+        }
+    }
+}
+exports.ZaloLoginByQr = ZaloLoginByQr;