n8n-nodes-pragma-bitrix24 1.0.0

package/dist/nodes/Bitrix24Tool/bitrix24.svg

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<svg width="32px" height="32px" viewBox="0 0 32 32" version="1.1" xmlns="http://www.w3.org/2000/svg">
+    <g stroke="none" stroke-width="1" fill="none" fill-rule="evenodd">
+        <path d="M16,0 C24.8365,0 32,7.1635 32,16 C32,24.8365 24.8365,32 16,32 C7.1635,32 0,24.8365 0,16 C0,7.1635 7.1635,0 16,0" fill="#2FC7F7"/>
+        <path d="M13.3333,8 L18.6667,8 C21.6122,8 24,10.3878 24,13.3333 L24,18.6667 C24,21.6122 21.6122,24 18.6667,24 L13.3333,24 C10.3878,24 8,21.6122 8,18.6667 L8,13.3333 C8,10.3878 10.3878,8 13.3333,8" fill="#FFFFFF"/>
+    </g>
+</svg> 

package/dist/nodes/Bitrix24Trigger/Bitrix24Trigger.node.js

@@ -0,0 +1,184 @@
+"use strict";
+/**
+ * Bitrix24 Trigger — Нода триггера событий
+ *
+ * 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.Bitrix24Trigger = void 0;
+class Bitrix24Trigger {
+    constructor() {
+        this.description = {
+            displayName: 'Bitrix24 Триггер',
+            name: 'bitrix24Trigger',
+            icon: 'file:bitrix24.svg',
+            group: ['trigger'],
+            version: 1,
+            description: 'Получение событий из Битрикс24: CRM, задачи, диск и другие',
+            defaults: {
+                name: 'Bitrix24 Триггер',
+            },
+            inputs: [],
+            outputs: ['main'],
+            webhooks: [
+                {
+                    name: 'default',
+                    httpMethod: 'POST',
+                    responseMode: 'onReceived',
+                    path: 'webhook',
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Events',
+                    name: 'events',
+                    type: 'multiOptions',
+                    options: [
+                        { name: 'On Bot Message Add', value: 'ONIMBOTMESSAGEADD' },
+                        { name: 'On App Install', value: 'ONAPPINSTALL' },
+                        { name: 'On Bot Join Chat', value: 'ONIMBOTJOINCHAT' },
+                        { name: 'On Bot Delete', value: 'ONIMBOTDELETE' },
+                        { name: 'On Bot Command Add', value: 'ONIMCOMMANDADD' },
+                        { name: 'Custom (Advanced)', value: 'custom' },
+                    ],
+                    default: ['ONIMBOTMESSAGEADD', 'ONAPPINSTALL'],
+                    required: true,
+                    description: 'Select events to listen to',
+                },
+                {
+                    displayName: 'Custom Event Name',
+                    name: 'customEvent',
+                    type: 'string',
+                    default: '',
+                    displayOptions: { show: { events: ['custom'] } },
+                    description: 'Enter the exact Bitrix24 event name (e.g. ONCRMDEALADD, ONTASKADD). Case sensitive.',
+                },
+                {
+                    displayName: 'Application Token (Verification)',
+                    name: 'appToken',
+                    type: 'string',
+                    typeOptions: { password: true },
+                    default: '',
+                    description: 'Secret token from Bitrix24 App settings to verify request authenticity (Recommended)',
+                },
+            ],
+        };
+    }
+    async webhook() {
+        const req = this.getRequestObject();
+        const body = req.body;
+        // Security Check
+        const appToken = this.getNodeParameter('appToken', '');
+        if (appToken) {
+            const incomingToken = body.auth?.application_token || body.data?.application_token || body.application_token;
+            if (incomingToken !== appToken) {
+                // Invalid token
+                return {}; // Silent reject or throw error? Silent is better for security to not leak info.
+            }
+        }
+        // Extract event name (Bitrix sends it as 'event')
+        const event = body.event;
+        // Check if we care about this event
+        const events = this.getNodeParameter('events');
+        let isMatch = events.includes(event);
+        if (!isMatch && events.includes('custom')) {
+            const customEvent = this.getNodeParameter('customEvent', '');
+            if (customEvent && customEvent === event) {
+                isMatch = true;
+            }
+        }
+        if (!isMatch) {
+            return {}; // Ignore
+        }
+        // Helper to flatten/clean bitrix weird payload like "data[PARAMS][MESSAGE]"
+        const parseBitrixPayload = (raw) => {
+            const result = { raw };
+            // Extract Auth usually present in all events
+            if (raw.auth) {
+                result.auth = raw.auth; // access_token, expires, application_token, etc.
+            }
+            else {
+                // Try to find flat auth keys
+                result.auth = {};
+                Object.keys(raw).forEach(k => {
+                    if (k.startsWith('auth[')) {
+                        const subKey = k.match(/auth\[(.*?)\]/)?.[1];
+                        if (subKey)
+                            result.auth[subKey] = raw[k];
+                    }
+                });
+            }
+            // Extract Data
+            if (raw.data) {
+                // If nested object
+                if (typeof raw.data === 'object') {
+                    result.data = raw.data;
+                }
+            }
+            else {
+                // Flat data
+                result.data = {};
+                Object.keys(raw).forEach(k => {
+                    if (k.startsWith('data[')) {
+                        // Simple flattener logic could be complex due to nesting data[PARAMS][MESSAGE]
+                        // For now, let's keep it somewhat raw or simple flat
+                        result.data[k] = raw[k];
+                    }
+                });
+            }
+            // Optimized Parsing for ONIMBOTMESSAGEADD
+            if (event === 'ONIMBOTMESSAGEADD') {
+                // Try to extract MESSAGE, DIALOG_ID, etc.
+                // Usually data[PARAMS][MESSAGE]
+                const getParam = (name) => {
+                    return raw.data?.PARAMS?.[name] || raw[`data[PARAMS][${name}]`];
+                };
+                result.message = getParam('MESSAGE');
+                result.dialog_id = getParam('DIALOG_ID');
+                result.chat_id = getParam('CHAT_ID');
+                result.bot_id = raw.data?.BOT?.[Object.keys(raw.data?.BOT || {})[0]]?.BOT_ID
+                    || Object.keys(raw).find(k => k.includes('[BOT_ID]')) ? raw[Object.keys(raw).find(k => k.includes('[BOT_ID]'))] : undefined;
+                // Files Parsing could be added here
+            }
+            else if (event === 'ONAPPINSTALL') {
+                result.auth_code = raw.auth?.code || result.auth.code;
+            }
+            else {
+                // Generic Parsing for Custom Events (CRM, Tasks, etc.)
+                // Usually data[FIELDS][ID] or data[ID]
+                if (result.data?.FIELDS) {
+                    Object.assign(result, result.data.FIELDS);
+                }
+                // Flatten data[...] keys for generic access
+                Object.keys(raw).forEach(k => {
+                    if (k.startsWith('data[')) {
+                        const subKey = k.match(/data\[(.*?)\]/)?.[1];
+                        if (subKey && !result[subKey])
+                            result[subKey] = raw[k];
+                    }
+                });
+            }
+            return result;
+        };
+        const returnData = parseBitrixPayload(body);
+        returnData.event = event;
+        return {
+            workflowData: [
+                [
+                    {
+                        json: returnData,
+                    },
+                ],
+            ],
+        };
+    }
+}
+exports.Bitrix24Trigger = Bitrix24Trigger;

package/dist/nodes/Bitrix24User/Bitrix24User.node.js

@@ -0,0 +1,351 @@
+"use strict";
+/**
+ * Bitrix24 User — Нода управления пользователями
+ *
+ * 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.Bitrix24User = void 0;
+const n8n_workflow_1 = require("n8n-workflow");
+const Helpers_1 = require("../Bitrix24/Helpers");
+class Bitrix24User {
+    constructor() {
+        this.description = {
+            displayName: 'Bitrix24 Пользователи',
+            name: 'bitrix24User',
+            icon: 'file:bitrix24.svg',
+            group: ['transform'],
+            version: 1,
+            subtitle: '={{$parameter["resource"] + ": " + $parameter["operation"]}}',
+            description: 'Управление пользователями, группами и оргструктурой в Битрикс24',
+            defaults: {
+                name: 'Bitrix24 Пользователи',
+            },
+            inputs: ['main'],
+            outputs: ['main'],
+            credentials: [
+                {
+                    name: 'bitrix24Api',
+                    required: true,
+                },
+            ],
+            properties: [
+                {
+                    displayName: 'Ресурс',
+                    name: 'resource',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Пользователь',
+                            value: 'user',
+                            description: 'Сотрудники компании: поиск, профили, фильтрация',
+                        },
+                        {
+                            name: 'Рабочая группа',
+                            value: 'sonet_group',
+                            description: 'Социальные группы и проекты',
+                        },
+                        {
+                            name: 'Отдел',
+                            value: 'department',
+                            description: 'Организационная структура компании',
+                        },
+                        {
+                            name: 'График отсутствия',
+                            value: 'absence',
+                            description: 'Отпуска, больничные, командировки',
+                        },
+                    ],
+                    default: 'user',
+                    required: true,
+                },
+                {
+                    displayName: 'Операция',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        {
+                            name: 'Получить',
+                            value: 'get',
+                            action: 'Получить пользователя или группу',
+                            description: 'Получить данные по ID',
+                            displayOptions: {
+                                show: {
+                                    resource: ['user', 'sonet_group'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Создать',
+                            value: 'create',
+                            action: 'Create/Invite a user',
+                            displayOptions: {
+                                show: {
+                                    resource: ['user'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Invite',
+                            value: 'invite',
+                            action: 'Invite a user',
+                            description: 'Add user and send invitation',
+                            displayOptions: {
+                                show: {
+                                    resource: ['user'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Get Current',
+                            value: 'getCurrent',
+                            action: 'Get current user',
+                            displayOptions: {
+                                show: {
+                                    resource: ['user'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Update',
+                            value: 'update',
+                            action: 'Update a user',
+                            displayOptions: {
+                                show: {
+                                    resource: ['user'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Delete',
+                            value: 'delete',
+                            action: 'Delete a user',
+                            displayOptions: {
+                                show: {
+                                    resource: ['user'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Search',
+                            value: 'search',
+                            action: 'Search users or groups',
+                            displayOptions: {
+                                show: {
+                                    resource: ['user', 'sonet_group'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Get All',
+                            value: 'getAll',
+                            action: 'Get all departments',
+                            displayOptions: {
+                                show: {
+                                    resource: ['department'],
+                                },
+                            },
+                        },
+                    ],
+                    default: 'get',
+                    required: true,
+                },
+                {
+                    displayName: 'ID',
+                    name: 'id',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            operation: ['get', 'update', 'delete'],
+                        },
+                    },
+                    description: 'ID of the user or group',
+                },
+                // User Create/Update Fields
+                {
+                    displayName: 'Email',
+                    name: 'email',
+                    type: 'string',
+                    default: '',
+                    displayOptions: { show: { resource: ['user'], operation: ['create', 'update'] } },
+                    required: true, // Required for create usually
+                },
+                {
+                    displayName: 'Extranet',
+                    name: 'extranet',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: { show: { resource: ['user'], operation: ['create'] } },
+                    description: 'Is extranet user?',
+                },
+                {
+                    displayName: 'First Name',
+                    name: 'name',
+                    type: 'string',
+                    default: '',
+                    displayOptions: { show: { resource: ['user'], operation: ['update'] } },
+                },
+                {
+                    displayName: 'Last Name',
+                    name: 'lastName',
+                    type: 'string',
+                    default: '',
+                    displayOptions: { show: { resource: ['user'], operation: ['update'] } },
+                },
+                {
+                    displayName: 'Departments',
+                    name: 'userDepartments',
+                    type: 'string',
+                    default: '',
+                    displayOptions: { show: { resource: ['user'], operation: ['update'] } },
+                    description: 'Comma separated department IDs (e.g. 1,5)',
+                },
+                {
+                    displayName: 'Start Date (Legacy)',
+                    name: 'dateStart',
+                    type: 'dateTime',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['user'],
+                            operation: ['search'],
+                        },
+                    },
+                    description: 'Filter users by last update date (optional)',
+                },
+                {
+                    displayName: 'Active Only',
+                    name: 'active',
+                    type: 'boolean',
+                    default: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['user'],
+                            operation: ['search'],
+                        },
+                    },
+                    description: 'Whether to return only active users',
+                },
+            ],
+        };
+    }
+    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 {
+                let endpoint = '';
+                let body = {};
+                if (resource === 'user') {
+                    if (operation === 'get') {
+                        endpoint = 'user.get';
+                        const id = this.getNodeParameter('id', i);
+                        body.ID = id;
+                    }
+                    else if (operation === 'getCurrent') {
+                        endpoint = 'user.current';
+                    }
+                    else if (operation === 'create' || operation === 'invite') {
+                        endpoint = 'user.add';
+                        body.EMAIL = this.getNodeParameter('email', i);
+                        body.EXTRANET = this.getNodeParameter('extranet', i) ? 'Y' : 'N';
+                    }
+                    else if (operation === 'update') {
+                        endpoint = 'user.update';
+                        body.ID = this.getNodeParameter('id', i);
+                        const email = this.getNodeParameter('email', i);
+                        if (email)
+                            body.EMAIL = email;
+                        const name = this.getNodeParameter('name', i);
+                        if (name)
+                            body.NAME = name;
+                        const lastName = this.getNodeParameter('lastName', i);
+                        if (lastName)
+                            body.LAST_NAME = lastName;
+                        const depts = this.getNodeParameter('userDepartments', i);
+                        if (depts)
+                            body.UF_DEPARTMENT = depts.split(',').map(d => parseInt(d.trim()));
+                    }
+                    else if (operation === 'delete') {
+                        // user.delete checks rights. Often used just to fire (active=N)
+                        // But here is explicit delete.
+                        endpoint = 'user.delete';
+                        body.ID = this.getNodeParameter('id', i);
+                    }
+                    else if (operation === 'search') {
+                        endpoint = 'user.get'; // Best practice for search
+                        const active = this.getNodeParameter('active', i);
+                        if (active)
+                            body.ACTIVE = 'Y';
+                    }
+                }
+                else if (resource === 'sonet_group') {
+                    if (operation === 'get') {
+                        endpoint = 'sonet_group.get';
+                        const id = this.getNodeParameter('id', i);
+                        body = {
+                            FILTER: { ID: id },
+                        };
+                    }
+                    else if (operation === 'search') {
+                        endpoint = 'sonet_group.get';
+                    }
+                }
+                else if (resource === 'department') {
+                    endpoint = 'department.get';
+                }
+                else if (resource === 'absence') {
+                    endpoint = 'user.absence.get';
+                    // Valid params: USER_ID, DATE_START, DATE_FINISH
+                    // For now, simple list
+                }
+                if (!endpoint) {
+                    throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Operation ${operation} on ${resource} not implemented yet`);
+                }
+                const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', endpoint + '.json', body);
+                let results = response.result;
+                if (Array.isArray(results)) {
+                    for (const item of results) {
+                        returnData.push({
+                            json: item,
+                            pairedItem: { item: i },
+                        });
+                    }
+                }
+                else {
+                    returnData.push({
+                        json: results,
+                        pairedItem: { item: i },
+                    });
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    const err = error;
+                    returnData.push({
+                        json: { error: err.message },
+                        pairedItem: { item: i },
+                    });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Bitrix24User = Bitrix24User;