n8n-nodes-pragma-bitrix24 1.0.0

package/dist/nodes/Bitrix24Telephony/Bitrix24Telephony.node.js

@@ -0,0 +1,511 @@
+"use strict";
+/**
+ * Bitrix24 Telephony — Нода управления телефонией
+ *
+ * Bitrix24 PRAGMA.by nodes for n8n
+ * Профессиональная интеграция с Битрикс24.
+ *
+ * @author PRAGMA & Азбука Решений
+ * @copyright 2026 PRAGMA (https://pragma.by/) & Азбука Решений (https://abc-solution.ru/)
+ *
+ * Контакты:
+ * 🇧🇾 PRAGMA: +375 (44) 702-70-90 | https://pragma.by/
+ * 🇷🇺 Азбука Решений: +7 (939) 555-19-60 | https://abc-solution.ru/
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Bitrix24Telephony = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const Helpers_1 = require("../Bitrix24/Helpers");
+class Bitrix24Telephony {
+    constructor() {
+        this.description = {
+            displayName: 'Bitrix24 Телефония',
+            name: 'bitrix24Telephony',
+            icon: 'file:bitrix24.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
+            description: 'Управление звонками, записями разговоров и внешней телефонией',
+            defaults: {
+                name: 'Bitrix24 Телефония',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'bitrix24Api',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Resource',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Call Statistic (History)',
+                            value: 'statistic',
+                            description: 'Get call history and recording IDs',
+                        },
+                        {
+                            name: 'Call Recording',
+                            value: 'recording',
+                            description: 'Get download URL for call recording',
+                        },
+                        {
+                            name: 'External Call',
+                            value: 'external_call',
+                            description: 'Register and finish calls from external PBX',
+                        },
+                        {
+                            name: 'SIP Line',
+                            value: 'sip_line',
+                            description: 'List SIP lines and status',
+                        },
+                        {
+                            name: 'User Settings',
+                            value: 'user_settings',
+                            description: 'Manage user extensions and telephony settings',
+                        },
+                    ],
+                    default: 'statistic',
+                    required: true,
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'List',
+                            value: 'list',
+                            description: 'List call statistics',
+                            action: 'List call statistics',
+                            displayOptions: {
+                                show: {
+                                    resource: ['statistic'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Get Download URL',
+                            value: 'get_url',
+                            description: 'Get temporary download URL for recording',
+                            action: 'Get recording url',
+                            displayOptions: {
+                                show: {
+                                    resource: ['recording'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Register Call',
+                            value: 'register',
+                            action: 'Register an external call',
+                            displayOptions: {
+                                show: {
+                                    resource: ['external_call'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Finish Call',
+                            value: 'finish',
+                            action: 'Finish an external call',
+                            displayOptions: {
+                                show: {
+                                    resource: ['external_call'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Attach Record (External)',
+                            value: 'attach_record_external',
+                            action: 'Attach record to external call',
+                            displayOptions: {
+                                show: {
+                                    resource: ['external_call'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Search CRM',
+                            value: 'search_crm',
+                            action: 'Search CRM by phone',
+                            displayOptions: {
+                                show: {
+                                    resource: ['external_call'],
+                                },
+                            },
+                        },
+                        // SIP & User
+                        {
+                            name: 'List', // Reused
+                            value: 'list',
+                            action: 'List items',
+                            displayOptions: {
+                                show: {
+                                    resource: ['statistic', 'sip_line', 'user_settings'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Get',
+                            value: 'get',
+                            action: 'Get item',
+                            displayOptions: {
+                                show: {
+                                    resource: ['user_settings'], // specific user
+                                },
+                            },
+                        },
+                        {
+                            name: 'Update',
+                            value: 'update',
+                            action: 'Update item',
+                            displayOptions: {
+                                show: {
+                                    resource: ['user_settings'],
+                                },
+                            },
+                        },
+                    ],
+                    default: 'list',
+                    required: true,
+                },
+                // Recording Fields
+                {
+                    displayName: 'Record File ID',
+                    name: 'recordId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['recording'],
+                            operation: ['get_url'],
+                        },
+                    },
+                    description: 'ID of the recording file (from Statistic)',
+                },
+                // External Call Fields
+                {
+                    displayName: 'Phone Number',
+                    name: 'phoneNumber',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['external_call'],
+                            operation: ['register', 'search_crm'],
+                        },
+                    },
+                    description: 'Phone number involved in the call',
+                },
+                {
+                    displayName: 'Call Type',
+                    name: 'callType',
+                    type: 'options',
+                    options: [
+                        { name: 'Outgoing', value: '1' },
+                        { name: 'Incoming', value: '2' },
+                        { name: 'Incoming with Redirection', value: '3' },
+                        { name: 'Callback', value: '4' },
+                    ],
+                    default: '2',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['external_call'],
+                            operation: ['register'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'User ID',
+                    name: 'userId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['external_call', 'user_settings'],
+                            operation: ['register', 'finish', 'get', 'update'],
+                        },
+                    },
+                    description: 'User ID responsible or involved',
+                },
+                {
+                    displayName: 'Call ID (External)',
+                    name: 'callId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['external_call'],
+                            operation: ['finish', 'attach_record_external'],
+                        },
+                    },
+                    description: 'Call ID returned by register method',
+                },
+                {
+                    displayName: 'Duration (Sec)',
+                    name: 'duration',
+                    type: 'number',
+                    default: 0,
+                    displayOptions: {
+                        show: {
+                            resource: ['external_call'],
+                            operation: ['finish'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Record URL',
+                    name: 'recordUrl',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['external_call'],
+                            operation: ['attach_record_external'],
+                        },
+                    },
+                    description: 'Publicly accessible URL of the record file',
+                },
+                // User Settings
+                {
+                    displayName: 'Inner Phone (Extension)',
+                    name: 'innerPhone',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['user_settings'],
+                            operation: ['update'],
+                        },
+                    },
+                },
+                // List Fields
+                {
+                    displayName: 'Return All',
+                    name: 'returnAll',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            operation: ['list'],
+                        },
+                    },
+                    description: 'Whether to return all results or only up to a given limit',
+                },
+                {
+                    displayName: 'Limit',
+                    name: 'limit',
+                    type: 'number',
+                    default: 50,
+                    displayOptions: {
+                        show: {
+                            operation: ['list'],
+                            returnAll: [false],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Filter JSON',
+                    name: 'filterJson',
+                    type: 'json',
+                    default: '{}',
+                    displayOptions: {
+                        show: {
+                            operation: ['list'],
+                        },
+                    },
+                    description: 'Filter parameters',
+                },
+            ],
+        };
+    }
+    async execute() {
+        const items = this.getInputData();
+        const returnData = [];
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        for (let i = 0; i < items.length; i++) {
+            try {
+                if (resource === 'statistic' && operation === 'list') {
+                    const returnAll = this.getNodeParameter('returnAll', i);
+                    const filterJson = this.getNodeParameter('filterJson', i, '{}');
+                    let filter = {};
+                    try {
+                        filter = JSON.parse(filterJson);
+                    }
+                    catch (e) { }
+                    const body = { filter, sort: { CALL_START_DATE: 'DESC' } };
+                    const limit = returnAll ? 100000 : this.getNodeParameter('limit', i);
+                    // voximplant.statistic.get supports pagination
+                    // But docs say max 1000 per request? Usually 50.
+                    if (returnAll) {
+                        let start = 0;
+                        let hasMore = true;
+                        while (hasMore) {
+                            // Safety break usually needed?
+                            // voximplant.statistic.get acts like list methods ?
+                            // Docs: "next" parameter is not mentioned standardly, usually 'start' works.
+                            // But some Bitrix methods use 'next'. 'voximplant.statistic.get' normally uses 'start'.
+                            // Actually, telephony statistics might require special handling.
+                            // Let's assume standard 'start' for now, check docs if fails.
+                            // Docs say: returns list.
+                            body.start = start;
+                            const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'voximplant.statistic.get.json', body);
+                            const results = response.result;
+                            if (!results || results.length === 0) {
+                                hasMore = false;
+                            }
+                            else {
+                                for (const item of results) {
+                                    returnData.push({
+                                        json: item,
+                                        pairedItem: { item: i },
+                                    });
+                                }
+                                start += results.length;
+                                if (results.length < 50)
+                                    hasMore = false;
+                            }
+                        }
+                    }
+                    else {
+                        // Single page
+                        // Note: Bitrix might ignore limit param in body and just use server limit (50).
+                        // We might need to slice result if user wants 10.
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'voximplant.statistic.get.json', body);
+                        let results = response.result;
+                        if (results) {
+                            if (limit < results.length) {
+                                results = results.slice(0, limit);
+                            }
+                            for (const item of results) {
+                                returnData.push({
+                                    json: item,
+                                    pairedItem: { item: i },
+                                });
+                            }
+                        }
+                    }
+                }
+                // External Call Logic
+                if (resource === 'external_call') {
+                    if (operation === 'register') {
+                        const PHONE_NUMBER = this.getNodeParameter('phoneNumber', i);
+                        const USER_ID = this.getNodeParameter('userId', i);
+                        const TYPE = this.getNodeParameter('callType', i);
+                        // Other optional params like CRM_CREATE, CALL_START_DATE ignored for brevity unless requested
+                        const body = { PHONE_NUMBER, USER_ID, TYPE, CRM_CREATE: 1, CALL_START_DATE: new Date().toISOString() };
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'telephony.externalcall.register.json', body);
+                        returnData.push({ json: response.result, pairedItem: { item: i } });
+                    }
+                    if (operation === 'finish') {
+                        const CADLL_ID = this.getNodeParameter('callId', i);
+                        const USER_ID = this.getNodeParameter('userId', i);
+                        const DURATION = this.getNodeParameter('duration', i);
+                        const body = { CALL_ID: CADLL_ID, USER_ID, DURATION, STATUS_CODE: 200 };
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'telephony.externalcall.finish.json', body);
+                        returnData.push({ json: response.result, pairedItem: { item: i } });
+                    }
+                    if (operation === 'attach_record_external') {
+                        const CALL_ID = this.getNodeParameter('callId', i);
+                        const FILENAME = 'record.mp3'; // Default
+                        const RECORD_URL = this.getNodeParameter('recordUrl', i);
+                        const body = { CALL_ID, FILENAME, RECORD_URL };
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'telephony.externalCall.attachRecord.json', body);
+                        returnData.push({ json: response.result, pairedItem: { item: i } });
+                    }
+                    if (operation === 'search_crm') {
+                        const PHONE_NUMBER = this.getNodeParameter('phoneNumber', i);
+                        const body = { PHONE_NUMBER };
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'telephony.externalCall.searchCrmEntities.json', body);
+                        returnData.push({ json: response.result, pairedItem: { item: i } });
+                    }
+                }
+                // SIP Line Logic
+                if (resource === 'sip_line') {
+                    if (operation === 'list') {
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'voximplant.sip.get.json', {});
+                        const results = response.result || [];
+                        for (const item of results) {
+                            returnData.push({ json: item, pairedItem: { item: i } });
+                        }
+                    }
+                }
+                // User Settings Logic
+                if (resource === 'user_settings') {
+                    if (operation === 'list') {
+                        // voximplant.user.get returns all if no filter?
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'voximplant.user.get.json', {});
+                        const results = response.result || [];
+                        for (const item of results) {
+                            returnData.push({ json: item, pairedItem: { item: i } });
+                        }
+                    }
+                    if (operation === 'get') {
+                        const USER_ID = this.getNodeParameter('userId', i);
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'voximplant.user.get.json', { ID: USER_ID });
+                        // Returns array usually
+                        const results = response.result || [];
+                        if (results.length > 0) {
+                            returnData.push({ json: results[0], pairedItem: { item: i } });
+                        }
+                        else {
+                            // Return empty or error? Empty better.
+                        }
+                    }
+                    if (operation === 'update') {
+                        const USER_ID = this.getNodeParameter('userId', i);
+                        const USER_PHONE_INNER = this.getNodeParameter('innerPhone', i);
+                        const body = { ID: USER_ID, USER_PHONE_INNER };
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'voximplant.user.update.json', body);
+                        returnData.push({ json: response.result, pairedItem: { item: i } });
+                    }
+                }
+                if (resource === 'recording' && operation === 'get_url') {
+                    const recordId = this.getNodeParameter('recordId', i);
+                    // Use disk.file.get to retrieve download URL
+                    const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'disk.file.get.json', { id: recordId });
+                    const result = response.result;
+                    if (result && result.DOWNLOAD_URL) {
+                        returnData.push({
+                            json: {
+                                recordId,
+                                downloadUrl: result.DOWNLOAD_URL,
+                                fileName: result.NAME,
+                                size: result.SIZE
+                            },
+                            pairedItem: { item: i },
+                        });
+                    }
+                    else {
+                        throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Could not retrieve download URL. File might be deleted or access denied.', { itemIndex: i });
+                    }
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({
+                        json: { error: error.message },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Bitrix24Telephony = Bitrix24Telephony;