@drivelock/n8n-nodes-drivelock 0.1.2 → 0.2.0

package/dist/nodes/Drivelock/Drivelock.node.js

@@ -34,16 +34,22 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Drivelock = void 0;
-const GenericFunctions_1 = require("./GenericFunctions");
+const GenericFunctions_1 = require("./helper/GenericFunctions");
 const n8n_workflow_1 = require("n8n-workflow");
-const CustomPropertyOperations_1 = require("./CustomPropertyOperations");
-const BinariesOperations_1 = require("./BinariesOperations");
-const customPropHelper = __importStar(require("./CustomPropertyHelper"));
-const ApplicationRulePropertyOperations_1 = require("./ApplicationRulePropertyOperations");
+const customPropHelper = __importStar(require("./helper/CustomPropertyHelper"));
+const ApplicationRuleOperations_1 = require("./operations/ApplicationRuleOperations");
+const BinariesOperations_1 = require("./operations/BinariesOperations");
+const ComputerOperations_1 = require("./operations/ComputerOperations");
+const CustomPropertyOperations_1 = require("./operations/CustomPropertyOperations");
+const DeviceRuleOperations_1 = require("./operations/DeviceRuleOperations");
+const DriveRuleOperations_1 = require("./operations/DriveRuleOperations");
+const EntityOperations_1 = require("./operations/EntityOperations");
+const GroupOperations_1 = require("./operations/GroupOperations");
+const PolicyOperations_1 = require("./operations/PolicyOperations");
 class Drivelock {
     constructor() {
         this.description = {
-            displayName: 'DriveLock',
+            displayName: 'DriveLock API',
             name: 'drivelock',
             icon: 'file:drivelock.svg',
             group: ['transform'],
@@ -52,7 +58,7 @@ class Drivelock {
             subtitle: '={{$if($parameter["operation"], $parameter["operation"] + " : ", "") + $parameter["resource"]}}',
             description: 'Consume DriveLock API',
             defaults: {
-                name: 'DriveLock Software',
+                name: 'DriveLock API',
             },
             inputs: [n8n_workflow_1.NodeConnectionTypes.Main],
             outputs: [n8n_workflow_1.NodeConnectionTypes.Main],
@@ -60,7 +66,7 @@ class Drivelock {
                 {
                     name: 'driveLockApi',
                     required: true,
-                    testedBy: 'driveLockApiTest'
+                    testedBy: 'driveLockApiTest',
                 }
             ],
             usableAsTool: true,
@@ -72,30 +78,45 @@ class Drivelock {
                     noDataExpression: true,
                     options: [
                         {
-                            name: 'Manage Computer',
-                            value: 'computers',
-                            description: 'Manage the computers',
+                            name: 'Application Rule',
+                            value: 'applicationRules',
+                            description: 'Manage application rules',
                         },
                         {
-                            name: 'Manage User',
-                            value: 'users',
-                            description: 'Manage the users',
+                            name: 'Computer',
+                            value: 'computer',
+                            description: 'Manage computers',
                         },
                         {
-                            name: 'Manage Device',
-                            value: 'devices',
-                            description: 'Manage the devices',
+                            name: 'Device Rule',
+                            value: 'deviceRules',
+                            description: 'Manage device rules',
                         },
                         {
-                            name: 'Manage Software',
-                            value: 'software',
-                            description: 'Manage the software',
-                        },
-                        {
-                            name: 'Manage Binary',
+                            name: 'Binary',
                             value: 'binaries',
                             description: 'Manage binaries',
                         },
+                        {
+                            name: 'Entity',
+                            value: 'entity',
+                            description: 'Manage entities',
+                        },
+                        {
+                            name: 'Group',
+                            value: 'group',
+                            description: 'Manage groups',
+                        },
+                        {
+                            name: 'Policy',
+                            value: 'policy',
+                            description: 'Manage policies',
+                        },
+                        {
+                            name: 'Tool',
+                            value: 'tool',
+                            description: 'Tool to handle DriveLock node data',
+                        },
                         {
                             name: 'Manage Schema Extention',
                             value: 'customproperty',
@@ -104,9 +125,35 @@ class Drivelock {
                     ],
                     default: 'customproperty',
                 },
-                ...CustomPropertyOperations_1.customPropertyOperations,
+                {
+                    displayName: 'Operation',
+                    name: 'operation',
+                    type: 'options',
+                    noDataExpression: true,
+                    displayOptions: {
+                        show: {
+                            resource: ['tool'],
+                        },
+                    },
+                    options: [
+                        {
+                            name: 'Change JSON Data-Return to Item Array',
+                            value: 'changeoutput',
+                            description: 'Change the output',
+                            action: 'Change JSON data return to item array',
+                        },
+                    ],
+                    default: 'changeoutput',
+                },
+                ...ApplicationRuleOperations_1.applicationRuleOperations,
                 ...BinariesOperations_1.binariesOperations,
-                ...ApplicationRulePropertyOperations_1.applicationRulePropertyOperations,
+                ...ComputerOperations_1.computerOperations,
+                ...CustomPropertyOperations_1.customPropertyOperations,
+                ...DeviceRuleOperations_1.deviceRuleOperations,
+                ...DriveRuleOperations_1.driveRuleOperations,
+                ...EntityOperations_1.entityOperations,
+                ...GroupOperations_1.groupOperations,
+                ...PolicyOperations_1.policyOperations,
             ],
         };
         this.methods = {
@@ -145,15 +192,69 @@ class Drivelock {
         };
     }
     async execute() {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
         const items = this.getInputData();
         const returnData = [];
         const length = items.length;
+        const resource = this.getNodeParameter('resource', 0);
+        const operation = this.getNodeParameter('operation', 0);
+        const credentialType = 'driveLockApi';
+        const credentials = await this.getCredentials(credentialType);
+        const baseUrl = (credentials.baseUrl || 'https://api.drivelock.cloud').replace(/\/$/, '');
+        const extractResponseData = (response) => {
+            if (!response)
+                return { success: true };
+            if (typeof response === 'string')
+                return { data: response };
+            if (typeof response === 'object' && response !== null) {
+                const responseObj = response;
+                const { errorId, error, data, total, additionalInfo, ...rest } = responseObj;
+                const result = {
+                    success: !error,
+                };
+                if (errorId !== undefined && errorId !== null) {
+                    result.errorId = errorId;
+                }
+                if (error !== undefined && error !== null) {
+                    result.error = error;
+                }
+                if (data !== undefined) {
+                    result.data = data;
+                }
+                if (total !== undefined) {
+                    result.total = total;
+                }
+                if (additionalInfo !== undefined && additionalInfo !== null) {
+                    result.additionalInfo = additionalInfo;
+                }
+                Object.keys(rest).forEach(key => {
+                    if (rest[key] !== undefined && rest[key] !== null) {
+                        result[key] = rest[key];
+                    }
+                });
+                return result;
+            }
+            return { success: true, data: response };
+        };
         for (let i = 0; i < length; i++) {
             try {
-                const resource = this.getNodeParameter('resource', i);
-                const operation = this.getNodeParameter('operation', i);
-                if (resource === 'customproperty') {
+                if (resource === 'tool') {
+                    if (operation === 'changeoutput') {
+                        const items = this.getInputData();
+                        const returnData = items.flatMap((item) => {
+                            var _a;
+                            const dataArray = (_a = item === null || item === void 0 ? void 0 : item.json) === null || _a === void 0 ? void 0 : _a.data;
+                            if (!Array.isArray(dataArray)) {
+                                return [];
+                            }
+                            return dataArray.map((dataItem) => ({
+                                json: dataItem
+                            }));
+                        });
+                        return [returnData];
+                    }
+                }
+                else if (resource === 'customproperty') {
                     const schema = this.getNodeParameter('schema', i);
                     const schemaExtention = `${schema}Extensions`;
                     if (operation === 'check') {
@@ -195,8 +296,7 @@ class Drivelock {
                         const success = (allPropertiesFound && allDataTypesCorrect);
                         const responseData = { allPropertiesFound, allDataTypesCorrect, allNotChanged, details: checkResult };
                         if (success) {
-                            const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
-                            returnData.push(...executionData);
+                            returnData.push(responseData);
                         }
                         else {
                             const outputData = JSON.stringify(responseData);
@@ -218,8 +318,7 @@ class Drivelock {
                         const payload = customPropHelper.createSetPayload(customPropertyId.value, updateProperties);
                         const url = `/api/administration/entity/customSchema/setCustomData/${schemaExtention}`;
                         await GenericFunctions_1.driveLockApiRequest.call(this, 'POST', url, payload);
-                        const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray({ success: true, payload: payload }), { itemData: { item: i } });
-                        returnData.push(...executionData);
+                        returnData.push({ success: true, payload: payload });
                     }
                 }
                 else if (resource === 'binaries') {
@@ -250,42 +349,676 @@ class Drivelock {
                         };
                         if (!getFullObject)
                             qs.select = `id,${select_fields},`;
-                        qs.take = 10;
+                        qs.take = 500;
+                        let limit = -1;
                         if (!returnAll) {
-                            const limit = this.getNodeParameter('limit', i);
+                            limit = this.getNodeParameter('limit', i);
                             if (qs.take > limit)
                                 qs.take = limit;
                         }
                         const responseData = await (GenericFunctions_1.driveLockApiRequest).call(this, 'GET', endpoint, {}, qs);
                         const total = (_f = responseData.total) !== null && _f !== void 0 ? _f : 0;
-                        if (total > qs.take) {
+                        if ((returnAll && qs.take < total) ||
+                            (!returnAll && qs.take < limit)) {
                             while (((_g = responseData.data) === null || _g === void 0 ? void 0 : _g.length) < total) {
                                 qs.skip = (_h = responseData.data) === null || _h === void 0 ? void 0 : _h.length;
+                                if (!returnAll) {
+                                    const nextAll = ((_j = responseData.data) === null || _j === void 0 ? void 0 : _j.length) + qs.take;
+                                    if (nextAll > limit)
+                                        qs.take = nextAll - (nextAll - limit);
+                                }
                                 const additionalData = await (GenericFunctions_1.driveLockApiRequest).call(this, 'GET', endpoint, {}, qs);
                                 if (!Array.isArray(additionalData.data)) {
                                     throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Some custom properties are missing or have incorrect data types. Details`, { itemIndex: i });
                                 }
                                 responseData.data.push(...additionalData.data);
+                                if (!returnAll && ((_k = responseData.data) === null || _k === void 0 ? void 0 : _k.length) >= limit)
+                                    break;
                             }
                         }
-                        responseData.n8nProcessedTotal = (_j = responseData.data) === null || _j === void 0 ? void 0 : _j.length;
+                        responseData.n8nProcessedTotal = (_l = responseData.data) === null || _l === void 0 ? void 0 : _l.length;
                         if (responseData) {
-                            const executionData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray(responseData), { itemData: { item: i } });
-                            returnData.push(...executionData);
+                            returnData.push(responseData);
+                        }
+                    }
+                }
+                else if (resource === 'computer') {
+                    if (operation === 'delete') {
+                        const computerIdsStr = this.getNodeParameter('computerIds', i);
+                        const computerIds = computerIdsStr.split(',').map(id => id.trim());
+                        const deleteRecoveryData = this.getNodeParameter('deleteRecoveryData', i);
+                        const deleteEvents = this.getNodeParameter('deleteEvents', i);
+                        const deleteGroupDefinitions = this.getNodeParameter('deleteGroupDefinitions', i);
+                        const body = {
+                            computerIds,
+                            deleteRecoveryData,
+                            deleteEvents,
+                            deleteGroupDefinitions,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'POST',
+                            url: `${baseUrl}/api/administration/computer/delete`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'executeActions') {
+                        const computerIdsStr = this.getNodeParameter('computerIds', i);
+                        const computerIds = computerIdsStr.split(',').map(id => id.trim());
+                        const actionsStr = this.getNodeParameter('actions', i);
+                        const notifyAgent = this.getNodeParameter('notifyAgent', i);
+                        let actions;
+                        try {
+                            actions = JSON.parse(actionsStr);
+                        }
+                        catch {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in actions field');
+                        }
+                        const body = {
+                            computerIds,
+                            actions,
+                            notifyAgent,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'POST',
+                            url: `${baseUrl}/api/administration/computer/actions`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'onlineUnlock') {
+                        const computerId = this.getNodeParameter('computerId', i);
+                        const unlockDataStr = this.getNodeParameter('unlockData', i);
+                        let data;
+                        try {
+                            data = JSON.parse(unlockDataStr);
+                        }
+                        catch {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in unlock data field');
+                        }
+                        const body = {
+                            computerId,
+                            data,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'POST',
+                            url: `${baseUrl}/api/administration/computer/online/unlock`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'stopOnlineUnlock') {
+                        const computerId = this.getNodeParameter('computerId', i);
+                        const body = {
+                            computerId,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'POST',
+                            url: `${baseUrl}/api/administration/computer/online/stopUnlock`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'markForRejoin') {
+                        const computerIdsStr = this.getNodeParameter('computerIds', i);
+                        const computerIds = computerIdsStr.split(',').map(id => id.trim());
+                        const allowToRejoin = this.getNodeParameter('allowToRejoin', i);
+                        const body = {
+                            computerIds,
+                            allowToRejoin,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'POST',
+                            url: `${baseUrl}/api/administration/computer/markAgentForRejoin`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                }
+                else if (resource === 'entity') {
+                    const entityName = this.getNodeParameter('entityName', i);
+                    if (operation === 'getList') {
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        const qs = {};
+                        if (additionalFields.select)
+                            qs.select = additionalFields.select;
+                        if (additionalFields.query)
+                            qs.query = additionalFields.query;
+                        if (additionalFields.sortBy)
+                            qs.sortBy = additionalFields.sortBy;
+                        if (additionalFields.groupBy)
+                            qs.groupBy = additionalFields.groupBy;
+                        if (additionalFields.skip !== undefined)
+                            qs.skip = additionalFields.skip;
+                        if (additionalFields.take !== undefined)
+                            qs.take = additionalFields.take;
+                        if (additionalFields.getTotalCount !== undefined)
+                            qs.getTotalCount = additionalFields.getTotalCount;
+                        if (additionalFields.includeLinkedObjects !== undefined)
+                            qs.includeLinkedObjects = additionalFields.includeLinkedObjects;
+                        if (additionalFields.getFullObjects !== undefined)
+                            qs.getFullObjects = additionalFields.getFullObjects;
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'GET',
+                            url: `${baseUrl}/api/administration/entity/${entityName}`,
+                            qs,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'getCount') {
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        const qs = {};
+                        if (additionalFields.query)
+                            qs.query = additionalFields.query;
+                        if (additionalFields.groupBy)
+                            qs.groupBy = additionalFields.groupBy;
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'GET',
+                            url: `${baseUrl}/api/administration/entity/${entityName}/count`,
+                            qs,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'getById') {
+                        const entityId = this.getNodeParameter('entityId', i);
+                        const includeLinkedObjects = this.getNodeParameter('includeLinkedObjects', i);
+                        const qs = {
+                            includeLinkedObjects,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'GET',
+                            url: `${baseUrl}/api/administration/entity/${entityName}/${entityId}`,
+                            qs,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'export') {
+                        const exportFormat = this.getNodeParameter('exportFormat', i);
+                        const additionalFields = this.getNodeParameter('additionalFields', i);
+                        const exportOptions = this.getNodeParameter('exportOptions', i);
+                        const qs = {
+                            exportFormat,
+                        };
+                        if (additionalFields.select)
+                            qs.select = additionalFields.select;
+                        if (additionalFields.query)
+                            qs.query = additionalFields.query;
+                        if (additionalFields.sortBy)
+                            qs.sortBy = additionalFields.sortBy;
+                        if (additionalFields.groupBy)
+                            qs.groupBy = additionalFields.groupBy;
+                        if (additionalFields.skip !== undefined)
+                            qs.skip = additionalFields.skip;
+                        if (additionalFields.take !== undefined)
+                            qs.take = additionalFields.take;
+                        if (additionalFields.includeLinkedObjects !== undefined)
+                            qs.includeLinkedObjects = additionalFields.includeLinkedObjects;
+                        if (additionalFields.getFullObjects !== undefined)
+                            qs.getFullObjects = additionalFields.getFullObjects;
+                        if (exportOptions.readability !== undefined)
+                            qs.readability = exportOptions.readability;
+                        if (exportOptions.separator)
+                            qs.separator = exportOptions.separator;
+                        if (exportOptions.language)
+                            qs.language = exportOptions.language;
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'GET',
+                            url: `${baseUrl}/api/administration/entity/${entityName}/export`,
+                            qs,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                }
+                else if (resource === 'group') {
+                    const groupId = this.getNodeParameter('groupId', i);
+                    if (operation === 'addComputers') {
+                        const computerIdsStr = this.getNodeParameter('computerIds', i);
+                        const computerIds = computerIdsStr.split(',').map((id) => id.trim());
+                        const body = {
+                            groupId,
+                            computerIds,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'POST',
+                            url: `${baseUrl}/api/administration/group/${groupId}/members/add`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'removeComputers') {
+                        const computerIdsStr = this.getNodeParameter('computerIds', i);
+                        const computerIds = computerIdsStr.split(',').map((id) => id.trim());
+                        const body = {
+                            groupId,
+                            computerIds,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'POST',
+                            url: `${baseUrl}/api/administration/group/${groupId}/members/remove`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'setMembers') {
+                        const computerIdsStr = this.getNodeParameter('computerIds', i);
+                        const computerIds = computerIdsStr.split(',').map((id) => id.trim());
+                        const body = {
+                            groupId,
+                            computerIds,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'PUT',
+                            url: `${baseUrl}/api/administration/group/${groupId}/members`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'getMembers') {
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'GET',
+                            url: `${baseUrl}/api/administration/group/${groupId}/members`,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                }
+                else if (resource === 'applicationRules') {
+                    const configId = this.getNodeParameter('configId', i);
+                    const configVersion = this.getNodeParameter('configVersion', i);
+                    if (operation === 'getRules') {
+                        const qs = {
+                            configVersion: configVersion || undefined,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'GET',
+                            url: `${baseUrl}/api/administration/applicationControl/rules/${configId}`,
+                            qs,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'createRules') {
+                        const rulesStr = this.getNodeParameter('rules', i);
+                        let rules;
+                        try {
+                            rules = JSON.parse(rulesStr);
+                        }
+                        catch {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in rules field');
+                        }
+                        const body = {
+                            configId,
+                            configVersion: configVersion || undefined,
+                            rules,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'POST',
+                            url: `${baseUrl}/api/administration/applicationControl/rules`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'updateRules') {
+                        const rulesStr = this.getNodeParameter('rules', i);
+                        let rules;
+                        try {
+                            rules = JSON.parse(rulesStr);
                         }
+                        catch {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in rules field');
+                        }
+                        const body = {
+                            configId,
+                            configVersion: configVersion || undefined,
+                            rules,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'PATCH',
+                            url: `${baseUrl}/api/administration/applicationControl/rules`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'deleteRules') {
+                        const ruleIdsStr = this.getNodeParameter('ruleIds', i);
+                        const ruleIds = ruleIdsStr.split(',').map((id) => id.trim());
+                        const body = {
+                            configId,
+                            configVersion: configVersion || undefined,
+                            ruleIds,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'DELETE',
+                            url: `${baseUrl}/api/administration/applicationControl/rules`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                }
+                else if (resource === 'deviceRules') {
+                    const configId = this.getNodeParameter('configId', i);
+                    const configVersion = this.getNodeParameter('configVersion', i);
+                    if (operation === 'getRules') {
+                        const qs = {
+                            configVersion: configVersion || undefined,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'GET',
+                            url: `${baseUrl}/api/administration/deviceControl/rules/${configId}`,
+                            qs,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'getCollections') {
+                        const qs = {
+                            configVersion: configVersion || undefined,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'GET',
+                            url: `${baseUrl}/api/administration/deviceControl/collections/${configId}`,
+                            qs,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'createRules') {
+                        const rulesDataStr = this.getNodeParameter('rulesData', i);
+                        let rules;
+                        try {
+                            rules = JSON.parse(rulesDataStr);
+                        }
+                        catch {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in rules data field');
+                        }
+                        const body = {
+                            configId,
+                            configVersion: configVersion || undefined,
+                            rules,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'POST',
+                            url: `${baseUrl}/api/administration/deviceControl/rules`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'updateRules') {
+                        const rulesDataStr = this.getNodeParameter('rulesData', i);
+                        let rules;
+                        try {
+                            rules = JSON.parse(rulesDataStr);
+                        }
+                        catch {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in rules data field');
+                        }
+                        const body = {
+                            configId,
+                            configVersion: configVersion || undefined,
+                            rules,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'PATCH',
+                            url: `${baseUrl}/api/administration/deviceControl/rules`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'updateCollections') {
+                        const rulesDataStr = this.getNodeParameter('rulesData', i);
+                        let collections;
+                        try {
+                            collections = JSON.parse(rulesDataStr);
+                        }
+                        catch {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in collections data field');
+                        }
+                        const body = {
+                            configId,
+                            configVersion: configVersion || undefined,
+                            collections,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'PATCH',
+                            url: `${baseUrl}/api/administration/deviceControl/collections`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'deleteRules') {
+                        const ruleIdsStr = this.getNodeParameter('ruleIds', i);
+                        const ruleIds = ruleIdsStr.split(',').map((id) => id.trim());
+                        const body = {
+                            configId,
+                            configVersion: configVersion || undefined,
+                            ruleIds,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'DELETE',
+                            url: `${baseUrl}/api/administration/deviceControl/rules`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                }
+                else if (resource === 'driveRules') {
+                    const configId = this.getNodeParameter('configId', i);
+                    const configVersion = this.getNodeParameter('configVersion', i);
+                    if (operation === 'getRules') {
+                        const qs = {
+                            configVersion: configVersion || undefined,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'GET',
+                            url: `${baseUrl}/api/administration/driveControl/rules/${configId}`,
+                            qs,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'getCollections') {
+                        const qs = {
+                            configVersion: configVersion || undefined,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'GET',
+                            url: `${baseUrl}/api/administration/driveControl/collections/${configId}`,
+                            qs,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'createRules') {
+                        const rulesDataStr = this.getNodeParameter('rulesData', i);
+                        let rules;
+                        try {
+                            rules = JSON.parse(rulesDataStr);
+                        }
+                        catch {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in rules data field');
+                        }
+                        const body = {
+                            configId,
+                            configVersion: configVersion || undefined,
+                            rules,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'POST',
+                            url: `${baseUrl}/api/administration/driveControl/rules`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'updateRules') {
+                        const rulesDataStr = this.getNodeParameter('rulesData', i);
+                        let rules;
+                        try {
+                            rules = JSON.parse(rulesDataStr);
+                        }
+                        catch {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in rules data field');
+                        }
+                        const body = {
+                            configId,
+                            configVersion: configVersion || undefined,
+                            rules,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'PATCH',
+                            url: `${baseUrl}/api/administration/driveControl/rules`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'updateCollections') {
+                        const rulesDataStr = this.getNodeParameter('rulesData', i);
+                        let collections;
+                        try {
+                            collections = JSON.parse(rulesDataStr);
+                        }
+                        catch {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in collections data field');
+                        }
+                        const body = {
+                            configId,
+                            configVersion: configVersion || undefined,
+                            collections,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'PATCH',
+                            url: `${baseUrl}/api/administration/driveControl/collections`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'deleteRules') {
+                        const ruleIdsStr = this.getNodeParameter('ruleIds', i);
+                        const ruleIds = ruleIdsStr.split(',').map((id) => id.trim());
+                        const body = {
+                            configId,
+                            configVersion: configVersion || undefined,
+                            ruleIds,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'DELETE',
+                            url: `${baseUrl}/api/administration/driveControl/rules`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                }
+                else if (resource === 'policy') {
+                    if (operation === 'get') {
+                        const policyId = this.getNodeParameter('policyId', i);
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'GET',
+                            url: `${baseUrl}/api/administration/policy/${policyId}`,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'create') {
+                        const policyDataStr = this.getNodeParameter('policyData', i);
+                        let policyData;
+                        try {
+                            policyData = JSON.parse(policyDataStr);
+                        }
+                        catch {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in policy data field');
+                        }
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'POST',
+                            url: `${baseUrl}/api/administration/policy`,
+                            body: policyData,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'update') {
+                        const policyId = this.getNodeParameter('policyId', i);
+                        const policyDataStr = this.getNodeParameter('policyData', i);
+                        let policyData;
+                        try {
+                            policyData = JSON.parse(policyDataStr);
+                        }
+                        catch {
+                            throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Invalid JSON in policy data field');
+                        }
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'PATCH',
+                            url: `${baseUrl}/api/administration/policy/${policyId}`,
+                            body: policyData,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'delete') {
+                        const policyId = this.getNodeParameter('policyId', i);
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'DELETE',
+                            url: `${baseUrl}/api/administration/policy/${policyId}`,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'getAssignments') {
+                        const policyId = this.getNodeParameter('policyId', i);
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'GET',
+                            url: `${baseUrl}/api/administration/policy/${policyId}/assignments`,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
+                    }
+                    else if (operation === 'assignToGroups') {
+                        const policyId = this.getNodeParameter('policyId', i);
+                        const groupIdsStr = this.getNodeParameter('groupIds', i);
+                        const groupIds = groupIdsStr.split(',').map((id) => id.trim());
+                        const body = {
+                            policyId,
+                            groupIds,
+                        };
+                        const response = await this.helpers.httpRequestWithAuthentication.call(this, credentialType, {
+                            method: 'POST',
+                            url: `${baseUrl}/api/administration/policy/${policyId}/assign`,
+                            body,
+                            json: true,
+                        });
+                        returnData.push(extractResponseData(response));
                     }
                 }
             }
             catch (error) {
                 if (this.continueOnFail()) {
-                    const executionErrorData = this.helpers.constructExecutionMetaData(this.helpers.returnJsonArray({ error: error.message }), { itemData: { item: i } });
-                    returnData.push(...executionErrorData);
+                    returnData.push({ error: error.message });
                     continue;
                 }
                 throw error;
             }
         }
-        return [returnData];
+        return [this.helpers.returnJsonArray(returnData)];
     }
     ;
 }