n8n-nodes-arubaclearpass 1.0.0

package/dist/nodes/ArubaClearPass/descriptions/PolicyElements/RoleMapping.descriptions.js

@@ -0,0 +1,365 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.roleMappingProperties = exports.roleMappingFields = exports.roleMappingOperations = void 0;
+// Define operations for RoleMapping resource
+exports.roleMappingOperations = {
+    displayName: 'Operation',
+    name: 'operation',
+    type: 'options',
+    displayOptions: {
+        show: {
+            domain: ['PolicyElements'],
+            resource: ['RoleMapping'],
+        },
+    },
+    options: [
+        {
+            name: 'Create',
+            value: 'create',
+            description: 'Create a new role mapping',
+            action: 'Create a role mapping',
+        },
+        {
+            name: 'Delete',
+            value: 'delete',
+            description: 'Delete a role mapping',
+            action: 'Delete a role mapping',
+        },
+        {
+            name: 'Get',
+            value: 'get',
+            description: 'Get a role mapping by ID',
+            action: 'Get a role mapping',
+        },
+        {
+            name: 'Get By Name',
+            value: 'getByName',
+            description: 'Get a role mapping by name',
+            action: 'Get a role mapping by name',
+        },
+        {
+            name: 'List',
+            value: 'list',
+            description: 'Get all role mappings',
+            action: 'List all role mappings',
+        },
+        {
+            name: 'Update',
+            value: 'update',
+            description: 'Update a role mapping',
+            action: 'Update a role mapping',
+        },
+        {
+            name: 'Replace',
+            value: 'replace',
+            description: 'Replace a role mapping',
+            action: 'Replace a role mapping',
+        },
+        {
+            name: 'Delete By Name',
+            value: 'deleteByName',
+            description: 'Delete a role mapping by name',
+            action: 'Delete a role mapping by name',
+        },
+        {
+            name: 'Update By Name',
+            value: 'updateByName',
+            description: 'Update a role mapping by name',
+            action: 'Update a role mapping by name',
+        },
+        {
+            name: 'Replace By Name',
+            value: 'replaceByName',
+            description: 'Replace a role mapping by name',
+            action: 'Replace a role mapping by name',
+        },
+    ],
+    default: 'list',
+};
+// Define fields for RoleMapping resource
+exports.roleMappingFields = [
+    // Fields for ID-based operations
+    {
+        displayName: 'Role Mapping ID',
+        name: 'roleMappingId',
+        type: 'string',
+        required: true,
+        default: '',
+        displayOptions: {
+            show: {
+                domain: ['PolicyElements'],
+                resource: ['RoleMapping'],
+                operation: ['get', 'update', 'delete', 'replace'],
+            },
+        },
+        description: 'The ID of the role mapping',
+    },
+    // Fields for name-based operations
+    {
+        displayName: 'Name',
+        name: 'name',
+        type: 'string',
+        required: true,
+        default: '',
+        displayOptions: {
+            show: {
+                domain: ['PolicyElements'],
+                resource: ['RoleMapping'],
+                operation: ['getByName', 'deleteByName', 'updateByName', 'replaceByName'],
+            },
+        },
+        description: 'The unique name of the role mapping',
+    },
+    // Common fields for create and replace operations
+    {
+        displayName: 'Name',
+        name: 'name',
+        type: 'string',
+        required: true,
+        default: '',
+        displayOptions: {
+            show: {
+                domain: ['PolicyElements'],
+                resource: ['RoleMapping'],
+                operation: ['create', 'replace', 'replaceByName'],
+            },
+        },
+        description: 'Name of the role mapping policy',
+    },
+    {
+        displayName: 'Default Role Name',
+        name: 'default_role_name',
+        type: 'string',
+        required: true,
+        default: '',
+        displayOptions: {
+            show: {
+                domain: ['PolicyElements'],
+                resource: ['RoleMapping'],
+                operation: ['create', 'replace', 'replaceByName'],
+            },
+        },
+        description: 'Default role name for the role mapping',
+    },
+    {
+        displayName: 'Rule Combine Algorithm',
+        name: 'rule_combine_algo',
+        type: 'options',
+        options: [
+            {
+                name: 'First Applicable',
+                value: 'first-applicable',
+                description: 'Stop processing once a rule matches',
+            },
+            {
+                name: 'Evaluate All',
+                value: 'evaluate-all',
+                description: 'Process all rules regardless of matches',
+            },
+        ],
+        required: true,
+        default: 'first-applicable',
+        displayOptions: {
+            show: {
+                domain: ['PolicyElements'],
+                resource: ['RoleMapping'],
+                operation: ['create', 'replace', 'replaceByName'],
+            },
+        },
+        description: 'Algorithm to use when evaluating rules',
+    },
+    {
+        displayName: 'Description',
+        name: 'description',
+        type: 'string',
+        required: false,
+        default: '',
+        displayOptions: {
+            show: {
+                domain: ['PolicyElements'],
+                resource: ['RoleMapping'],
+                operation: ['create', 'replace', 'replaceByName'],
+            },
+        },
+        description: 'Description of the role mapping',
+    },
+    // Rules JSON Field for create/replace - This is complex, so we'll use JSON input
+    {
+        displayName: 'Rules',
+        name: 'rules',
+        type: 'json',
+        required: true,
+        default: '[]',
+        displayOptions: {
+            show: {
+                domain: ['PolicyElements'],
+                resource: ['RoleMapping'],
+                operation: ['create', 'replace', 'replaceByName'],
+            },
+        },
+        description: 'JSON array of mapping rules. Each rule should have match_type, role_name, and condition properties.',
+        placeholder: `[
+  {
+    "match_type": "AND", 
+    "role_name": "Guest", 
+    "condition": {
+      "type": "Connection", 
+      "name": "Connection:Protocol", 
+      "oper": "EQUALS", 
+      "value": "MAC"
+    }
+  }
+]`,
+    },
+    // Update fields
+    {
+        displayName: 'Update Fields',
+        name: 'updateFields',
+        type: 'collection',
+        placeholder: 'Add Field',
+        default: {},
+        displayOptions: {
+            show: {
+                domain: ['PolicyElements'],
+                resource: ['RoleMapping'],
+                operation: ['update', 'updateByName'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Name',
+                name: 'name',
+                type: 'string',
+                default: '',
+                description: 'Name of the role mapping policy',
+            },
+            {
+                displayName: 'Description',
+                name: 'description',
+                type: 'string',
+                default: '',
+                description: 'Description of the role mapping',
+            },
+            {
+                displayName: 'Default Role Name',
+                name: 'default_role_name',
+                type: 'string',
+                default: '',
+                description: 'Default role name for the role mapping',
+            },
+            {
+                displayName: 'Rule Combine Algorithm',
+                name: 'rule_combine_algo',
+                type: 'options',
+                options: [
+                    {
+                        name: 'First Applicable',
+                        value: 'first-applicable',
+                        description: 'Stop processing once a rule matches',
+                    },
+                    {
+                        name: 'Evaluate All',
+                        value: 'evaluate-all',
+                        description: 'Process all rules regardless of matches',
+                    },
+                ],
+                default: 'first-applicable',
+                description: 'Algorithm to use when evaluating rules',
+            },
+            {
+                displayName: 'Rules',
+                name: 'rules',
+                type: 'json',
+                default: '[]',
+                description: 'JSON array of mapping rules. Each rule should have match_type, role_name, and condition properties.',
+                placeholder: `[
+  {
+    "match_type": "AND", 
+    "role_name": "Guest", 
+    "condition": {
+      "type": "Connection", 
+      "name": "Connection:Protocol", 
+      "oper": "EQUALS", 
+      "value": "MAC"
+    }
+  }
+]`,
+            },
+        ],
+    },
+    // Fields for list operation
+    {
+        displayName: 'Return All',
+        name: 'returnAll',
+        type: 'boolean',
+        displayOptions: {
+            show: {
+                domain: ['PolicyElements'],
+                resource: ['RoleMapping'],
+                operation: ['list'],
+            },
+        },
+        default: false,
+        description: 'Whether to return all results or only up to a given limit',
+    },
+    {
+        displayName: 'Limit',
+        name: 'limit',
+        type: 'number',
+        displayOptions: {
+            show: {
+                domain: ['PolicyElements'],
+                resource: ['RoleMapping'],
+                operation: ['list'],
+                returnAll: [false],
+            },
+        },
+        typeOptions: {
+            minValue: 1,
+            maxValue: 1000,
+        },
+        default: 100,
+        description: 'Max number of results to return',
+    },
+    {
+        displayName: 'Filters',
+        name: 'filters',
+        type: 'collection',
+        placeholder: 'Add Filter',
+        default: {},
+        displayOptions: {
+            show: {
+                domain: ['PolicyElements'],
+                resource: ['RoleMapping'],
+                operation: ['list'],
+            },
+        },
+        options: [
+            {
+                displayName: 'Filter',
+                name: 'filter',
+                type: 'string',
+                default: '',
+                description: 'JSON filter expression specifying the items to return',
+                placeholder: '{"name": {"$contains": "Guest"}}',
+            },
+            {
+                displayName: 'Sort',
+                name: 'sort',
+                type: 'string',
+                default: '+id',
+                description: 'Sort ordering for returned items (default +id)',
+                placeholder: '+name or -created_at',
+            },
+            {
+                displayName: 'Calculate Count',
+                name: 'calculate_count',
+                type: 'boolean',
+                default: false,
+                description: 'Whether to calculate the total item count',
+            },
+        ],
+    },
+];
+// Export combined properties for use in index.ts
+exports.roleMappingProperties = [exports.roleMappingOperations, ...exports.roleMappingFields];

package/dist/nodes/ArubaClearPass/descriptions/PolicyElements/index.d.ts

@@ -0,0 +1,2 @@
+import { INodePropertyOptions } from 'n8n-workflow';
+export declare const policyElementsResources: INodePropertyOptions[];

package/dist/nodes/ArubaClearPass/descriptions/PolicyElements/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.policyElementsResources = void 0;
+// Define the resources for the PolicyElements domain
+exports.policyElementsResources = [
+    {
+        name: 'Role',
+        value: 'Role',
+    },
+    {
+        name: 'Role Mapping',
+        value: 'RoleMapping',
+    },
+    {
+        name: 'Enforcement Policy',
+        value: 'EnforcementPolicy',
+    },
+    // Add more resources as needed
+];

package/dist/nodes/ArubaClearPass/helpers/apiRequest.d.ts

@@ -0,0 +1,9 @@
+import { IExecuteFunctions, IHookFunctions, ILoadOptionsFunctions, IDataObject, IHttpRequestMethods } from 'n8n-workflow';
+/**
+ * Make an API request to Aruba ClearPass
+ */
+export declare function apiRequest(this: IExecuteFunctions | ILoadOptionsFunctions | IHookFunctions, method: IHttpRequestMethods, endpoint: string, body?: IDataObject, query?: IDataObject): Promise<any>;
+/**
+ * Make paginated API requests to Aruba ClearPass and return all results
+ */
+export declare function apiRequestAllItems(this: IExecuteFunctions | ILoadOptionsFunctions, method: IHttpRequestMethods, endpoint: string, body?: IDataObject, query?: IDataObject): Promise<any>;

package/dist/nodes/ArubaClearPass/helpers/apiRequest.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiRequest = apiRequest;
+exports.apiRequestAllItems = apiRequestAllItems;
+// helpers/apiRequest.ts
+const n8n_workflow_1 = require("n8n-workflow");
+const tokenManager_1 = require("./tokenManager");
+/**
+ * Make an API request to Aruba ClearPass
+ */
+async function apiRequest(method, endpoint, body = {}, query = {}) {
+    const credentials = (await this.getCredentials('clearPassApi'));
+    const baseUrl = credentials.url;
+    const options = {
+        method,
+        url: `${baseUrl}/api${endpoint}`,
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        qs: query,
+        body,
+        json: true,
+    };
+    if (Object.keys(body).length === 0) {
+        delete options.body;
+    }
+    try {
+        // If using Client ID/Secret auth, get token directly. Otherwise, use OAuth2 authentication
+        if (credentials.authType === 'clientCredentials') {
+            const token = await tokenManager_1.getToken.call(this, credentials);
+            options.headers = {
+                ...options.headers,
+                Authorization: `Bearer ${token}`,
+            };
+            return await this.helpers.request(options);
+        }
+        else {
+            // OAuth2 authentication (processed by n8n)
+            return await this.helpers.requestWithAuthentication.call(this, 'clearPassApi', options);
+        }
+    }
+    catch (error) {
+        // Fix error handling
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), error);
+    }
+}
+/**
+ * Make paginated API requests to Aruba ClearPass and return all results
+ */
+async function apiRequestAllItems(method, endpoint, body = {}, query = {}) {
+    const returnData = [];
+    // Set initial parameters for pagination
+    let responseData;
+    query.limit = query.limit || 100;
+    query.offset = 0;
+    do {
+        responseData = await apiRequest.call(this, method, endpoint, body, query);
+        if (responseData._embedded && responseData._embedded.items) {
+            returnData.push.apply(returnData, responseData._embedded.items);
+        }
+        else if (Array.isArray(responseData)) {
+            returnData.push.apply(returnData, responseData);
+        }
+        else {
+            returnData.push(responseData);
+        }
+        query.offset = query.offset + query.limit;
+    } while (responseData._embedded &&
+        responseData._embedded.items &&
+        responseData._embedded.items.length === query.limit);
+    return returnData;
+}

package/dist/nodes/ArubaClearPass/helpers/errorHandler.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Handle common error scenarios for ClearPass API
+ */
+export declare function handleApiError(node: any, error: any): never;

package/dist/nodes/ArubaClearPass/helpers/errorHandler.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleApiError = handleApiError;
+// helpers/errorHandler.ts
+const n8n_workflow_1 = require("n8n-workflow");
+/**
+ * Handle common error scenarios for ClearPass API
+ */
+function handleApiError(node, error) {
+    let errorMessage = 'An error occurred while making the API request: ';
+    // Handle standard API error responses
+    if (error.response && error.response.body) {
+        const body = error.response.body;
+        if (typeof body.detail === 'string') {
+            errorMessage += body.detail;
+        }
+        else if (typeof body.message === 'string') {
+            errorMessage += body.message;
+        }
+        else if (typeof body.title === 'string') {
+            errorMessage += body.title;
+        }
+        else {
+            errorMessage += JSON.stringify(body);
+        }
+    }
+    else if (error.message) {
+        errorMessage += error.message;
+    }
+    throw new n8n_workflow_1.NodeApiError(node, error, { message: errorMessage });
+}

package/dist/nodes/ArubaClearPass/helpers/executeOperation.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+/**
+ * Execute the appropriate operation based on user selection
+ */
+export declare function executeOperation(this: IExecuteFunctions): Promise<INodeExecutionData[]>;

package/dist/nodes/ArubaClearPass/helpers/executeOperation.js

@@ -0,0 +1,164 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeOperation = executeOperation;
+const deviceMethods = __importStar(require("../methods/Identities/Device.methods"));
+const endpointMethods = __importStar(require("../methods/Identities/Endpoint.methods"));
+const guestUserMethods = __importStar(require("../methods/Identities/GuestUser.methods"));
+const localUserMethods = __importStar(require("../methods/Identities/LocalUser.methods"));
+const roleMethods = __importStar(require("../methods/PolicyElements/Role.methods"));
+const roleMappingMethods = __importStar(require("../methods/PolicyElements/RoleMapping.methods"));
+const enforcementPolicyMethods = __importStar(require("../methods/PolicyElements/EnforcementPolicy.methods"));
+const enforcementProfileMethods = __importStar(require("../methods/EnforcementProfile/EnforcementProfile.methods"));
+// ... Add more methods for other endpoints here
+/**
+ * Execute the appropriate operation based on user selection
+ */
+async function executeOperation() {
+    const domain = this.getNodeParameter('domain', 0);
+    const resource = this.getNodeParameter('resource', 0);
+    const operation = this.getNodeParameter('operation', 0);
+    console.log(`Executing ${domain}.${resource}.${operation}`);
+    // Define handlers for each domain/resource/operation combination
+    const handlers = {
+        Identities: {
+            Device: {
+                list: deviceMethods.listDevices,
+                get: deviceMethods.getDevice,
+                getByMac: deviceMethods.getDeviceByMac,
+                create: deviceMethods.createDevice,
+                update: deviceMethods.updateDevice,
+                updateByMac: deviceMethods.updateDeviceByMac,
+                replace: deviceMethods.replaceDevice,
+                replaceByMac: deviceMethods.replaceDeviceByMac,
+                delete: deviceMethods.deleteDevice,
+                deleteByMac: deviceMethods.deleteDeviceByMac,
+            },
+            Endpoint: {
+                list: endpointMethods.listEndpoints,
+                get: endpointMethods.getEndpoint,
+                getByMac: endpointMethods.getEndpointByMac,
+                create: endpointMethods.createEndpoint,
+                update: endpointMethods.updateEndpoint,
+                updateByMac: endpointMethods.updateEndpointByMac,
+                delete: endpointMethods.deleteEndpoint,
+                deleteByMac: endpointMethods.deleteEndpointByMac,
+            },
+            GuestUser: {
+                // Add this section for GuestUser operations
+                list: guestUserMethods.listGuestUsers,
+                get: guestUserMethods.getGuestUser,
+                getByUsername: guestUserMethods.getGuestUserByUsername,
+                create: guestUserMethods.createGuestUser,
+                update: guestUserMethods.updateGuestUser,
+                updateByUsername: guestUserMethods.updateGuestUserByUsername,
+                replace: guestUserMethods.replaceGuestUser,
+                replaceByUsername: guestUserMethods.replaceGuestUserByUsername,
+                delete: guestUserMethods.deleteGuestUser,
+                deleteByUsername: guestUserMethods.deleteGuestUserByUsername,
+            },
+            LocalUser: {
+                list: localUserMethods.listLocalUsers,
+                get: localUserMethods.getLocalUser,
+                getByUserId: localUserMethods.getLocalUserByUserId,
+                create: localUserMethods.createLocalUser,
+                update: localUserMethods.updateLocalUser,
+                updateByUserId: localUserMethods.updateLocalUserByUserId,
+                replace: localUserMethods.replaceLocalUser,
+                replaceByUserId: localUserMethods.replaceLocalUserByUserId,
+                delete: localUserMethods.deleteLocalUser,
+                deleteByUserId: localUserMethods.deleteLocalUserByUserId,
+            },
+        },
+        PolicyElements: {
+            Role: {
+                list: roleMethods.listRoles,
+                get: roleMethods.getRole,
+                getByName: roleMethods.getRoleByName,
+                create: roleMethods.createRole,
+                update: roleMethods.updateRole,
+                updateByName: roleMethods.updateRoleByName,
+                replace: roleMethods.replaceRole,
+                replaceByName: roleMethods.replaceRoleByName,
+                delete: roleMethods.deleteRole,
+                deleteByName: roleMethods.deleteRoleByName,
+            },
+            RoleMapping: {
+                list: roleMappingMethods.listRoleMappings,
+                get: roleMappingMethods.getRoleMapping,
+                getByName: roleMappingMethods.getRoleMappingByName,
+                create: roleMappingMethods.createRoleMapping,
+                update: roleMappingMethods.updateRoleMapping,
+                updateByName: roleMappingMethods.updateRoleMappingByName,
+                replace: roleMappingMethods.replaceRoleMapping,
+                replaceByName: roleMappingMethods.replaceRoleMappingByName,
+                delete: roleMappingMethods.deleteRoleMapping,
+                deleteByName: roleMappingMethods.deleteRoleMappingByName,
+            },
+            EnforcementPolicy: {
+                list: enforcementPolicyMethods.listEnforcementPolicies,
+                get: enforcementPolicyMethods.getEnforcementPolicy,
+                getByName: enforcementPolicyMethods.getEnforcementPolicyByName,
+                create: enforcementPolicyMethods.createEnforcementPolicy,
+                update: enforcementPolicyMethods.updateEnforcementPolicy,
+                updateByName: enforcementPolicyMethods.updateEnforcementPolicyByName,
+                replace: enforcementPolicyMethods.replaceEnforcementPolicy,
+                replaceByName: enforcementPolicyMethods.replaceEnforcementPolicyByName,
+                delete: enforcementPolicyMethods.deleteEnforcementPolicy,
+                deleteByName: enforcementPolicyMethods.deleteEnforcementPolicyByName,
+            },
+            // Add other PolicyElements resources as needed
+        },
+        EnforcementProfile: {
+            EnforcementProfile: {
+                list: enforcementProfileMethods.listEnforcementProfiles,
+                get: enforcementProfileMethods.getEnforcementProfile,
+                getByName: enforcementProfileMethods.getEnforcementProfileByName,
+                create: enforcementProfileMethods.createEnforcementProfile,
+                update: enforcementProfileMethods.updateEnforcementProfile,
+                updateByName: enforcementProfileMethods.updateEnforcementProfileByName,
+                replace: enforcementProfileMethods.replaceEnforcementProfile,
+                replaceByName: enforcementProfileMethods.replaceEnforcementProfileByName,
+                delete: enforcementProfileMethods.deleteEnforcementProfile,
+                deleteByName: enforcementProfileMethods.deleteEnforcementProfileByName,
+            },
+        },
+        // Add other domain resources as needed
+    };
+    if (!handlers[domain] || !handlers[domain][resource] || !handlers[domain][resource][operation]) {
+        throw new Error(`The operation ${domain}.${resource}.${operation} is not supported!`);
+    }
+    return await handlers[domain][resource][operation].call(this);
+}

package/dist/nodes/ArubaClearPass/helpers/responseFormatter.d.ts

@@ -0,0 +1,5 @@
+import { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+/**
+ * Format the API response data into n8n node execution data
+ */
+export declare function formatResponse(this: IExecuteFunctions, responseData: any): INodeExecutionData[];