n8n-nodes-arubaclearpass 1.0.0

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatResponse = formatResponse;
+/**
+ * Format the API response data into n8n node execution data
+ */
+function formatResponse(responseData) {
+    if (!responseData) {
+        return [{ json: { success: true } }];
+    }
+    if (!Array.isArray(responseData)) {
+        return [{ json: responseData }];
+    }
+    return responseData.map((item) => ({
+        json: item,
+    }));
+}

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

@@ -0,0 +1,5 @@
+import { IDataObject, IExecuteFunctions, IHookFunctions, ILoadOptionsFunctions } from 'n8n-workflow';
+/**
+ * Get a bearer token using client credentials
+ */
+export declare function getToken(this: IExecuteFunctions | IHookFunctions | ILoadOptionsFunctions, credentials: IDataObject): Promise<string>;

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

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getToken = getToken;
+// helpers/tokenManager.ts
+const n8n_workflow_1 = require("n8n-workflow");
+// Store tokens in memory with expiration
+const tokenCache = {};
+/**
+ * Get a bearer token using client credentials
+ */
+async function getToken(credentials) {
+    const clientId = credentials.clientId;
+    const clientSecret = credentials.clientSecret;
+    const baseUrl = credentials.url;
+    // Generate a cache key based on client credentials
+    const cacheKey = `${baseUrl}:${clientId}:${clientSecret}`;
+    // Check if we have a valid cached token
+    const cachedToken = tokenCache[cacheKey];
+    if (cachedToken && cachedToken.expiresAt > Date.now()) {
+        return cachedToken.token;
+    }
+    // If no valid token in cache, request a new one
+    try {
+        const options = {
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            method: 'POST',
+            body: {
+                client_id: clientId,
+                client_secret: clientSecret,
+                grant_type: 'client_credentials',
+            },
+            uri: `${baseUrl}/api/oauth`,
+            json: true,
+        };
+        const response = (await this.helpers.request(options));
+        // Cache the token with expiration (add some buffer to ensure we refresh before it expires)
+        const expiresInMs = response.expires_in * 1000 - 60000; // Subtract 1 minute as buffer
+        tokenCache[cacheKey] = {
+            token: response.access_token,
+            expiresAt: Date.now() + expiresInMs,
+        };
+        return response.access_token;
+    }
+    catch (error) {
+        // Fix error handling to use JsonObject without undefined properties
+        const errorObject = {};
+        if (error instanceof Error) {
+            errorObject.message = error.message;
+            // Only add stack if it exists, and convert to string to ensure it's a JsonValue
+            if (error.stack) {
+                errorObject.stackTrace = error.stack; // Changed property name and ensured it's not undefined
+            }
+        }
+        else {
+            errorObject.message = 'Unknown error when obtaining token';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject, {
+            message: 'Failed to obtain access token',
+        });
+    }
+}

package/dist/nodes/ArubaClearPass/methods/EnforcementProfile/EnforcementProfile.methods.d.ts

@@ -0,0 +1,41 @@
+import { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+/**
+ * List all enforcement profiles
+ */
+export declare function listEnforcementProfiles(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Create a new enforcement profile
+ */
+export declare function createEnforcementProfile(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Get an enforcement profile by ID
+ */
+export declare function getEnforcementProfile(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Get an enforcement profile by name
+ */
+export declare function getEnforcementProfileByName(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Update an enforcement profile by ID
+ */
+export declare function updateEnforcementProfile(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Update an enforcement profile by name
+ */
+export declare function updateEnforcementProfileByName(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Replace an enforcement profile by ID
+ */
+export declare function replaceEnforcementProfile(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Replace an enforcement profile by name
+ */
+export declare function replaceEnforcementProfileByName(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Delete an enforcement profile by ID
+ */
+export declare function deleteEnforcementProfile(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Delete an enforcement profile by name
+ */
+export declare function deleteEnforcementProfileByName(this: IExecuteFunctions): Promise<INodeExecutionData[]>;

package/dist/nodes/ArubaClearPass/methods/EnforcementProfile/EnforcementProfile.methods.js

@@ -0,0 +1,395 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listEnforcementProfiles = listEnforcementProfiles;
+exports.createEnforcementProfile = createEnforcementProfile;
+exports.getEnforcementProfile = getEnforcementProfile;
+exports.getEnforcementProfileByName = getEnforcementProfileByName;
+exports.updateEnforcementProfile = updateEnforcementProfile;
+exports.updateEnforcementProfileByName = updateEnforcementProfileByName;
+exports.replaceEnforcementProfile = replaceEnforcementProfile;
+exports.replaceEnforcementProfileByName = replaceEnforcementProfileByName;
+exports.deleteEnforcementProfile = deleteEnforcementProfile;
+exports.deleteEnforcementProfileByName = deleteEnforcementProfileByName;
+// methods/EnforcementProfile/EnforcementProfile.methods.ts
+const n8n_workflow_1 = require("n8n-workflow");
+const apiRequest_1 = require("../../helpers/apiRequest");
+const responseFormatter_1 = require("../../helpers/responseFormatter");
+/**
+ * List all enforcement profiles
+ */
+async function listEnforcementProfiles() {
+    try {
+        const returnAll = this.getNodeParameter('returnAll', 0);
+        const filters = this.getNodeParameter('filters', 0, {});
+        const endpoint = '/enforcement-profile';
+        let responseData;
+        if (returnAll) {
+            responseData = await apiRequest_1.apiRequestAllItems.call(this, 'GET', endpoint, {}, filters);
+        }
+        else {
+            const limit = this.getNodeParameter('limit', 0);
+            if (!filters.limit) {
+                filters.limit = limit;
+            }
+            responseData = await apiRequest_1.apiRequest.call(this, 'GET', endpoint, {}, filters);
+        }
+        return responseFormatter_1.formatResponse.call(this, responseData);
+    }
+    catch (error) {
+        const errorObject = {};
+        if (error instanceof Error) {
+            errorObject.message = error.message;
+            if (error.stack) {
+                errorObject.stackTrace = error.stack;
+            }
+        }
+        else {
+            errorObject.message = 'Unknown error in listEnforcementProfiles';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Create a new enforcement profile
+ */
+async function createEnforcementProfile() {
+    try {
+        const body = {};
+        // Add required fields
+        body.name = this.getNodeParameter('name', 0);
+        body.type = this.getNodeParameter('type', 0);
+        // Add optional fields
+        const description = this.getNodeParameter('description', 0, '');
+        if (description) {
+            body.description = description;
+        }
+        const action = this.getNodeParameter('action', 0, '');
+        if (action) {
+            body.action = action;
+        }
+        // Add complex configuration
+        const profileConfigJson = this.getNodeParameter('profileConfig', 0, '{}');
+        try {
+            const profileConfig = JSON.parse(profileConfigJson);
+            // Merge the profile config with the body
+            Object.entries(profileConfig).forEach(([key, value]) => {
+                body[key] = value;
+            });
+        }
+        catch (parseError) {
+            throw new Error(`Invalid JSON in profile configuration: ${parseError.message}`);
+        }
+        const endpoint = '/enforcement-profile';
+        const responseData = await apiRequest_1.apiRequest.call(this, 'POST', endpoint, body);
+        return responseFormatter_1.formatResponse.call(this, responseData);
+    }
+    catch (error) {
+        const errorObject = {};
+        if (error instanceof Error) {
+            errorObject.message = error.message;
+            if (error.stack) {
+                errorObject.stackTrace = error.stack;
+            }
+        }
+        else {
+            errorObject.message = 'Unknown error in createEnforcementProfile';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Get an enforcement profile by ID
+ */
+async function getEnforcementProfile() {
+    try {
+        const enforcementProfileId = this.getNodeParameter('enforcementProfileId', 0);
+        const endpoint = `/enforcement-profile/${enforcementProfileId}`;
+        const responseData = await apiRequest_1.apiRequest.call(this, 'GET', endpoint);
+        return responseFormatter_1.formatResponse.call(this, responseData);
+    }
+    catch (error) {
+        const errorObject = {};
+        if (error instanceof Error) {
+            errorObject.message = error.message;
+            if (error.stack) {
+                errorObject.stackTrace = error.stack;
+            }
+        }
+        else {
+            errorObject.message = 'Unknown error in getEnforcementProfile';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Get an enforcement profile by name
+ */
+async function getEnforcementProfileByName() {
+    try {
+        const name = this.getNodeParameter('name', 0);
+        const endpoint = `/enforcement-profile/name/${name}`;
+        const responseData = await apiRequest_1.apiRequest.call(this, 'GET', endpoint);
+        return responseFormatter_1.formatResponse.call(this, responseData);
+    }
+    catch (error) {
+        const errorObject = {};
+        if (error instanceof Error) {
+            errorObject.message = error.message;
+            if (error.stack) {
+                errorObject.stackTrace = error.stack;
+            }
+        }
+        else {
+            errorObject.message = 'Unknown error in getEnforcementProfileByName';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Update an enforcement profile by ID
+ */
+async function updateEnforcementProfile() {
+    try {
+        const enforcementProfileId = this.getNodeParameter('enforcementProfileId', 0);
+        const updateFields = this.getNodeParameter('updateFields', 0, {});
+        if (!Object.keys(updateFields).length) {
+            throw new Error('Please specify at least one field to update');
+        }
+        const body = {};
+        // Handle regular fields
+        if (updateFields.name)
+            body.name = updateFields.name;
+        if (updateFields.description)
+            body.description = updateFields.description;
+        if (updateFields.type)
+            body.type = updateFields.type;
+        if (updateFields.action)
+            body.action = updateFields.action;
+        // Handle complex profile configuration if provided
+        if (updateFields.profileConfig) {
+            try {
+                const profileConfig = JSON.parse(updateFields.profileConfig);
+                // Merge the profile config with the body
+                Object.entries(profileConfig).forEach(([key, value]) => {
+                    body[key] = value;
+                });
+            }
+            catch (parseError) {
+                throw new Error(`Invalid JSON in profile configuration: ${parseError.message}`);
+            }
+        }
+        const endpoint = `/enforcement-profile/${enforcementProfileId}`;
+        const responseData = await apiRequest_1.apiRequest.call(this, 'PATCH', endpoint, body);
+        return responseFormatter_1.formatResponse.call(this, responseData);
+    }
+    catch (error) {
+        const errorObject = {};
+        if (error instanceof Error) {
+            errorObject.message = error.message;
+            if (error.stack) {
+                errorObject.stackTrace = error.stack;
+            }
+        }
+        else {
+            errorObject.message = 'Unknown error in updateEnforcementProfile';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Update an enforcement profile by name
+ */
+async function updateEnforcementProfileByName() {
+    try {
+        const name = this.getNodeParameter('name', 0);
+        const updateFields = this.getNodeParameter('updateFields', 0, {});
+        if (!Object.keys(updateFields).length) {
+            throw new Error('Please specify at least one field to update');
+        }
+        const body = {};
+        // Handle regular fields
+        if (updateFields.name)
+            body.name = updateFields.name;
+        if (updateFields.description)
+            body.description = updateFields.description;
+        if (updateFields.type)
+            body.type = updateFields.type;
+        if (updateFields.action)
+            body.action = updateFields.action;
+        // Handle complex profile configuration if provided
+        if (updateFields.profileConfig) {
+            try {
+                const profileConfig = JSON.parse(updateFields.profileConfig);
+                // Merge the profile config with the body
+                Object.entries(profileConfig).forEach(([key, value]) => {
+                    body[key] = value;
+                });
+            }
+            catch (parseError) {
+                throw new Error(`Invalid JSON in profile configuration: ${parseError.message}`);
+            }
+        }
+        const endpoint = `/enforcement-profile/name/${name}`;
+        const responseData = await apiRequest_1.apiRequest.call(this, 'PATCH', endpoint, body);
+        return responseFormatter_1.formatResponse.call(this, responseData);
+    }
+    catch (error) {
+        const errorObject = {};
+        if (error instanceof Error) {
+            errorObject.message = error.message;
+            if (error.stack) {
+                errorObject.stackTrace = error.stack;
+            }
+        }
+        else {
+            errorObject.message = 'Unknown error in updateEnforcementProfileByName';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Replace an enforcement profile by ID
+ */
+async function replaceEnforcementProfile() {
+    try {
+        const enforcementProfileId = this.getNodeParameter('enforcementProfileId', 0);
+        const body = {};
+        // Add required fields
+        body.name = this.getNodeParameter('name', 0);
+        body.type = this.getNodeParameter('type', 0);
+        // Add optional fields
+        const description = this.getNodeParameter('description', 0, '');
+        if (description) {
+            body.description = description;
+        }
+        const action = this.getNodeParameter('action', 0, '');
+        if (action) {
+            body.action = action;
+        }
+        // Add complex configuration
+        const profileConfigJson = this.getNodeParameter('profileConfig', 0, '{}');
+        try {
+            const profileConfig = JSON.parse(profileConfigJson);
+            // Merge the profile config with the body
+            Object.entries(profileConfig).forEach(([key, value]) => {
+                body[key] = value;
+            });
+        }
+        catch (parseError) {
+            throw new Error(`Invalid JSON in profile configuration: ${parseError.message}`);
+        }
+        const endpoint = `/enforcement-profile/${enforcementProfileId}`;
+        const responseData = await apiRequest_1.apiRequest.call(this, 'PUT', endpoint, body);
+        return responseFormatter_1.formatResponse.call(this, responseData);
+    }
+    catch (error) {
+        const errorObject = {};
+        if (error instanceof Error) {
+            errorObject.message = error.message;
+            if (error.stack) {
+                errorObject.stackTrace = error.stack;
+            }
+        }
+        else {
+            errorObject.message = 'Unknown error in replaceEnforcementProfile';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Replace an enforcement profile by name
+ */
+async function replaceEnforcementProfileByName() {
+    try {
+        const name = this.getNodeParameter('name', 0);
+        const body = {};
+        // Add required fields
+        body.name = this.getNodeParameter('name', 0);
+        body.type = this.getNodeParameter('type', 0);
+        // Add optional fields
+        const description = this.getNodeParameter('description', 0, '');
+        if (description) {
+            body.description = description;
+        }
+        const action = this.getNodeParameter('action', 0, '');
+        if (action) {
+            body.action = action;
+        }
+        // Add complex configuration
+        const profileConfigJson = this.getNodeParameter('profileConfig', 0, '{}');
+        try {
+            const profileConfig = JSON.parse(profileConfigJson);
+            // Merge the profile config with the body
+            Object.entries(profileConfig).forEach(([key, value]) => {
+                body[key] = value;
+            });
+        }
+        catch (parseError) {
+            throw new Error(`Invalid JSON in profile configuration: ${parseError.message}`);
+        }
+        const endpoint = `/enforcement-profile/name/${name}`;
+        const responseData = await apiRequest_1.apiRequest.call(this, 'PUT', endpoint, body);
+        return responseFormatter_1.formatResponse.call(this, responseData);
+    }
+    catch (error) {
+        const errorObject = {};
+        if (error instanceof Error) {
+            errorObject.message = error.message;
+            if (error.stack) {
+                errorObject.stackTrace = error.stack;
+            }
+        }
+        else {
+            errorObject.message = 'Unknown error in replaceEnforcementProfileByName';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Delete an enforcement profile by ID
+ */
+async function deleteEnforcementProfile() {
+    try {
+        const enforcementProfileId = this.getNodeParameter('enforcementProfileId', 0);
+        const endpoint = `/enforcement-profile/${enforcementProfileId}`;
+        await apiRequest_1.apiRequest.call(this, 'DELETE', endpoint);
+        return [{ json: { success: true } }];
+    }
+    catch (error) {
+        const errorObject = {};
+        if (error instanceof Error) {
+            errorObject.message = error.message;
+            if (error.stack) {
+                errorObject.stackTrace = error.stack;
+            }
+        }
+        else {
+            errorObject.message = 'Unknown error in deleteEnforcementProfile';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Delete an enforcement profile by name
+ */
+async function deleteEnforcementProfileByName() {
+    try {
+        const name = this.getNodeParameter('name', 0);
+        const endpoint = `/enforcement-profile/name/${name}`;
+        await apiRequest_1.apiRequest.call(this, 'DELETE', endpoint);
+        return [{ json: { success: true } }];
+    }
+    catch (error) {
+        const errorObject = {};
+        if (error instanceof Error) {
+            errorObject.message = error.message;
+            if (error.stack) {
+                errorObject.stackTrace = error.stack;
+            }
+        }
+        else {
+            errorObject.message = 'Unknown error in deleteEnforcementProfileByName';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}

package/dist/nodes/ArubaClearPass/methods/Identities/Device.methods.d.ts

@@ -0,0 +1,41 @@
+import { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+/**
+ * List all device accounts
+ */
+export declare function listDevices(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Get a device account by ID
+ */
+export declare function getDevice(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Get a device account by MAC address
+ */
+export declare function getDeviceByMac(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Create a new device account
+ */
+export declare function createDevice(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Update a device account by ID
+ */
+export declare function updateDevice(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Update a device account by MAC address
+ */
+export declare function updateDeviceByMac(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Replace a device account by ID
+ */
+export declare function replaceDevice(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Replace a device account by MAC address
+ */
+export declare function replaceDeviceByMac(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Delete a device account by ID
+ */
+export declare function deleteDevice(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Delete a device account by MAC address
+ */
+export declare function deleteDeviceByMac(this: IExecuteFunctions): Promise<INodeExecutionData[]>;