n8n-nodes-pragma-bitrix24 1.0.0

package/dist/nodes/Bitrix24Lists/Bitrix24Lists.node.js

@@ -0,0 +1,406 @@
+"use strict";
+/**
+ * Bitrix24 Lists — Нода универсальных списков
+ *
+ * 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.Bitrix24Lists = void 0;
+const Helpers_1 = require("../Bitrix24/Helpers");
+class Bitrix24Lists {
+    constructor() {
+        this.description = {
+            displayName: 'Bitrix24 Списки',
+            name: 'bitrix24Lists',
+            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: 'Element',
+                            value: 'element',
+                            description: 'List items',
+                        },
+                        {
+                            name: 'List',
+                            value: 'list',
+                            description: 'List structure (IBlock)',
+                        },
+                        {
+                            name: 'Section',
+                            value: 'section',
+                            description: 'List folders/sections',
+                        },
+                        {
+                            name: 'Field',
+                            value: 'field',
+                            description: 'List fields/properties',
+                        },
+                    ],
+                    default: 'element',
+                    required: true,
+                },
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    options: [
+                        // Element
+                        {
+                            name: 'Get',
+                            value: 'get',
+                            action: 'Get an element',
+                            displayOptions: {
+                                show: {
+                                    resource: ['element', 'list', 'field'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'List',
+                            value: 'list',
+                            action: 'List elements',
+                            displayOptions: {
+                                show: {
+                                    resource: ['element', 'list', 'section', 'field'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Create',
+                            value: 'create',
+                            action: 'Create an element',
+                            displayOptions: {
+                                show: {
+                                    resource: ['element', 'section'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Update',
+                            value: 'update',
+                            action: 'Update an element',
+                            displayOptions: {
+                                show: {
+                                    resource: ['element', 'section'],
+                                },
+                            },
+                        },
+                        {
+                            name: 'Delete',
+                            value: 'delete',
+                            action: 'Delete an element',
+                            displayOptions: {
+                                show: {
+                                    resource: ['element', 'section'],
+                                },
+                            },
+                        },
+                    ],
+                    default: 'list',
+                    required: true,
+                },
+                {
+                    displayName: 'Group Type',
+                    name: 'groupType',
+                    type: 'options',
+                    options: [
+                        { name: 'Lists (Default)', value: 'lists' },
+                        { name: 'Bitrix Processes', value: 'bitrix_processes' },
+                        { name: 'Social Network', value: 'lists_socnet' },
+                    ],
+                    default: 'lists',
+                    description: 'IBLOCK_TYPE_ID parameter',
+                    required: true,
+                },
+                {
+                    displayName: 'List ID (IBlock ID)',
+                    name: 'iblockId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['element', 'section', 'field'],
+                        },
+                    },
+                    description: 'ID of the List (Information Block)',
+                },
+                {
+                    displayName: 'Element ID',
+                    name: 'elementId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['element'],
+                            operation: ['get', 'update', 'delete'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Section ID',
+                    name: 'sectionId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['section'],
+                            operation: ['update', 'delete'],
+                        },
+                    },
+                },
+                {
+                    displayName: 'Field ID',
+                    name: 'fieldId',
+                    type: 'string',
+                    default: '',
+                    required: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['field'],
+                            operation: ['get'],
+                        },
+                    },
+                },
+                // Create/Update Fields
+                {
+                    displayName: 'Name',
+                    name: 'name',
+                    type: 'string',
+                    default: '',
+                    displayOptions: {
+                        show: {
+                            resource: ['element', 'section'],
+                            operation: ['create'],
+                        },
+                    },
+                    required: true,
+                },
+                {
+                    displayName: 'Fields JSON',
+                    name: 'fieldsJson',
+                    type: 'json',
+                    default: '{}',
+                    description: 'Fields for the element (PROPERTY_VALUES)',
+                    displayOptions: {
+                        show: {
+                            resource: ['element'],
+                            operation: ['create', 'update'],
+                        },
+                    },
+                },
+                // List Options
+                {
+                    displayName: 'Return All',
+                    name: 'returnAll',
+                    type: 'boolean',
+                    default: false,
+                    displayOptions: {
+                        show: {
+                            operation: ['list'],
+                        },
+                    },
+                },
+                {
+                    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'],
+                        },
+                    },
+                },
+            ],
+        };
+    }
+    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 {
+                const groupType = this.getNodeParameter('groupType', i, 'lists');
+                let iblockId = '';
+                try {
+                    iblockId = this.getNodeParameter('iblockId', i);
+                }
+                catch (e) { }
+                if (resource === 'list') {
+                    if (operation === 'list') {
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'lists.get.json', { IBLOCK_TYPE_ID: groupType });
+                        const results = response.result || [];
+                        // Standard list filtering handled manually or by API? lists.get doesn't clearly state filter support
+                        // But usually lists are few.
+                        for (const item of results) {
+                            returnData.push({ json: item, pairedItem: { item: i } });
+                        }
+                    }
+                    if (operation === 'get') {
+                        // lists.get with filter? No direct 'get' by ID in docs usually, but we can filter list
+                        // Or maybe lists.get supports ID? docs say IBLOCK_ID is param.
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'lists.get.json', { IBLOCK_TYPE_ID: groupType, IBLOCK_ID: iblockId });
+                        const results = response.result || [];
+                        if (results.length > 0) {
+                            returnData.push({ json: results[0], pairedItem: { item: i } });
+                        }
+                    }
+                }
+                if (resource === 'element') {
+                    if (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 = {
+                            IBLOCK_TYPE_ID: groupType,
+                            IBLOCK_ID: iblockId,
+                            FILTER: filter
+                        };
+                        // lists.element.get
+                        if (returnAll) {
+                            let start = 0;
+                            let hasMore = true;
+                            while (hasMore) {
+                                body.start = start;
+                                const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'lists.element.get.json', body);
+                                const results = response.result || [];
+                                if (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 {
+                            const limit = this.getNodeParameter('limit', i);
+                            // Does lists.element.get support limit? Docs usually imply 'nPageSize' or similar,
+                            // but Bitrix standard is start/next often.
+                            // If no explicit limit param in method, we slice.
+                            // lists.element.get typically returns 50 by default.
+                            const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'lists.element.get.json', body);
+                            let results = response.result || [];
+                            if (limit < results.length)
+                                results = results.slice(0, limit);
+                            for (const item of results) {
+                                returnData.push({ json: item, pairedItem: { item: i } });
+                            }
+                        }
+                    }
+                    if (operation === 'create') {
+                        const name = this.getNodeParameter('name', i);
+                        const fieldsJson = this.getNodeParameter('fieldsJson', i, '{}');
+                        const fields = JSON.parse(fieldsJson);
+                        fields.NAME = name;
+                        const body = {
+                            IBLOCK_TYPE_ID: groupType,
+                            IBLOCK_ID: iblockId,
+                            ELEMENT_CODE: 'element_' + Date.now(), // Auto-gen code often required
+                            FIELDS: fields
+                        };
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'lists.element.add.json', body);
+                        // Returns ID usually
+                        returnData.push({ json: { id: response.result }, pairedItem: { item: i } });
+                    }
+                    if (operation === 'get') {
+                        const elementId = this.getNodeParameter('elementId', i);
+                        const body = { IBLOCK_TYPE_ID: groupType, IBLOCK_ID: iblockId, ELEMENT_ID: elementId };
+                        // lists.element.get with filter ID? or directly?
+                        // Docs: lists.element.get accepts FILTER: { ID: val }
+                        body.FILTER = { ID: elementId };
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'lists.element.get.json', body);
+                        const results = response.result || [];
+                        if (results.length > 0)
+                            returnData.push({ json: results[0], pairedItem: { item: i } });
+                    }
+                    if (operation === 'delete') {
+                        const elementId = this.getNodeParameter('elementId', i);
+                        const body = { IBLOCK_TYPE_ID: groupType, IBLOCK_ID: iblockId, ELEMENT_ID: elementId };
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'lists.element.delete.json', body);
+                        returnData.push({ json: { success: true, result: response.result }, pairedItem: { item: i } });
+                    }
+                }
+                if (resource === 'field') {
+                    if (operation === 'list') {
+                        const body = { IBLOCK_TYPE_ID: groupType, IBLOCK_ID: iblockId };
+                        const response = await Helpers_1.bitrixRequestWithRetry.call(this, 'POST', 'lists.field.get.json', body);
+                        const results = response.result;
+                        // Response is object { FIELD_ID: { ... }, ... } or array?
+                        // Usually object map.
+                        if (results) {
+                            // Converts object map to array
+                            Object.keys(results).forEach(key => {
+                                // @ts-ignore
+                                const field = results[key];
+                                returnData.push({ json: field, pairedItem: { item: i } });
+                            });
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                if (this.continueOnFail()) {
+                    returnData.push({ json: { error: error.message }, pairedItem: { item: i } });
+                    continue;
+                }
+                throw error;
+            }
+        }
+        return [returnData];
+    }
+}
+exports.Bitrix24Lists = Bitrix24Lists;