n8n-nodes-arubaclearpass 1.0.0

package/dist/nodes/ArubaClearPass/methods/PolicyElements/EnforcementPolicy.methods.js

@@ -0,0 +1,361 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listEnforcementPolicies = listEnforcementPolicies;
+exports.getEnforcementPolicy = getEnforcementPolicy;
+exports.getEnforcementPolicyByName = getEnforcementPolicyByName;
+exports.createEnforcementPolicy = createEnforcementPolicy;
+exports.updateEnforcementPolicy = updateEnforcementPolicy;
+exports.updateEnforcementPolicyByName = updateEnforcementPolicyByName;
+exports.replaceEnforcementPolicy = replaceEnforcementPolicy;
+exports.replaceEnforcementPolicyByName = replaceEnforcementPolicyByName;
+exports.deleteEnforcementPolicy = deleteEnforcementPolicy;
+exports.deleteEnforcementPolicyByName = deleteEnforcementPolicyByName;
+// methods/PolicyElements/EnforcementPolicy.methods.ts
+const n8n_workflow_1 = require("n8n-workflow");
+const apiRequest_1 = require("../../helpers/apiRequest");
+const responseFormatter_1 = require("../../helpers/responseFormatter");
+/**
+ * List all enforcement policies
+ */
+async function listEnforcementPolicies() {
+    try {
+        const returnAll = this.getNodeParameter('returnAll', 0);
+        const filters = this.getNodeParameter('filters', 0, {});
+        const endpoint = '/enforcement-policy';
+        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 listEnforcementPolicies';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Get an enforcement policy by ID
+ */
+async function getEnforcementPolicy() {
+    try {
+        const enforcementPolicyId = this.getNodeParameter('enforcementPolicyId', 0);
+        const endpoint = `/enforcement-policy/${enforcementPolicyId}`;
+        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 getEnforcementPolicy';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Get an enforcement policy by name
+ */
+async function getEnforcementPolicyByName() {
+    try {
+        const name = this.getNodeParameter('name', 0);
+        const endpoint = `/enforcement-policy/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 getEnforcementPolicyByName';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Create a new enforcement policy
+ */
+async function createEnforcementPolicy() {
+    try {
+        const body = {};
+        // Add required fields
+        body.name = this.getNodeParameter('name', 0);
+        body.enforcement_type = this.getNodeParameter('enforcement_type', 0);
+        body.default_enforcement_profile = this.getNodeParameter('default_enforcement_profile', 0);
+        body.rule_eval_algo = this.getNodeParameter('rule_eval_algo', 0);
+        // Add optional fields
+        const description = this.getNodeParameter('description', 0, '');
+        if (description) {
+            body.description = description;
+        }
+        // Add rules (required)
+        const rulesJson = this.getNodeParameter('rules', 0);
+        try {
+            body.rules = JSON.parse(rulesJson);
+        }
+        catch (parseError) {
+            throw new Error(`Invalid JSON in rules: ${parseError.message}`);
+        }
+        const endpoint = '/enforcement-policy';
+        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 createEnforcementPolicy';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Update an enforcement policy by ID
+ */
+async function updateEnforcementPolicy() {
+    try {
+        const enforcementPolicyId = this.getNodeParameter('enforcementPolicyId', 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 fields
+        Object.entries(updateFields).forEach(([key, value]) => {
+            if (key === 'rules' && typeof value === 'string') {
+                try {
+                    body[key] = JSON.parse(value);
+                }
+                catch (parseError) {
+                    throw new Error(`Invalid JSON in rules: ${parseError.message}`);
+                }
+            }
+            else {
+                body[key] = value;
+            }
+        });
+        const endpoint = `/enforcement-policy/${enforcementPolicyId}`;
+        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 updateEnforcementPolicy';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Update an enforcement policy by name
+ */
+async function updateEnforcementPolicyByName() {
+    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 fields
+        Object.entries(updateFields).forEach(([key, value]) => {
+            if (key === 'rules' && typeof value === 'string') {
+                try {
+                    body[key] = JSON.parse(value);
+                }
+                catch (parseError) {
+                    throw new Error(`Invalid JSON in rules: ${parseError.message}`);
+                }
+            }
+            else {
+                body[key] = value;
+            }
+        });
+        const endpoint = `/enforcement-policy/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 updateEnforcementPolicyByName';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Replace an enforcement policy by ID
+ */
+async function replaceEnforcementPolicy() {
+    try {
+        const enforcementPolicyId = this.getNodeParameter('enforcementPolicyId', 0);
+        const body = {};
+        // Add required fields
+        body.name = this.getNodeParameter('name', 0);
+        body.enforcement_type = this.getNodeParameter('enforcement_type', 0);
+        body.default_enforcement_profile = this.getNodeParameter('default_enforcement_profile', 0);
+        body.rule_eval_algo = this.getNodeParameter('rule_eval_algo', 0);
+        // Add optional fields
+        const description = this.getNodeParameter('description', 0, '');
+        if (description) {
+            body.description = description;
+        }
+        // Add rules (required)
+        const rulesJson = this.getNodeParameter('rules', 0);
+        try {
+            body.rules = JSON.parse(rulesJson);
+        }
+        catch (parseError) {
+            throw new Error(`Invalid JSON in rules: ${parseError.message}`);
+        }
+        const endpoint = `/enforcement-policy/${enforcementPolicyId}`;
+        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 replaceEnforcementPolicy';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Replace an enforcement policy by name
+ */
+async function replaceEnforcementPolicyByName() {
+    try {
+        const name = this.getNodeParameter('name', 0);
+        const body = {};
+        // Add required fields
+        body.name = this.getNodeParameter('name', 0);
+        body.enforcement_type = this.getNodeParameter('enforcement_type', 0);
+        body.default_enforcement_profile = this.getNodeParameter('default_enforcement_profile', 0);
+        body.rule_eval_algo = this.getNodeParameter('rule_eval_algo', 0);
+        // Add optional fields
+        const description = this.getNodeParameter('description', 0, '');
+        if (description) {
+            body.description = description;
+        }
+        // Add rules (required)
+        const rulesJson = this.getNodeParameter('rules', 0);
+        try {
+            body.rules = JSON.parse(rulesJson);
+        }
+        catch (parseError) {
+            throw new Error(`Invalid JSON in rules: ${parseError.message}`);
+        }
+        const endpoint = `/enforcement-policy/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 replaceEnforcementPolicyByName';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Delete an enforcement policy by ID
+ */
+async function deleteEnforcementPolicy() {
+    try {
+        const enforcementPolicyId = this.getNodeParameter('enforcementPolicyId', 0);
+        const endpoint = `/enforcement-policy/${enforcementPolicyId}`;
+        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 deleteEnforcementPolicy';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Delete an enforcement policy by name
+ */
+async function deleteEnforcementPolicyByName() {
+    try {
+        const name = this.getNodeParameter('name', 0);
+        const endpoint = `/enforcement-policy/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 deleteEnforcementPolicyByName';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}

package/dist/nodes/ArubaClearPass/methods/PolicyElements/Role.methods.d.ts

@@ -0,0 +1,41 @@
+import { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+/**
+ * List all roles
+ */
+export declare function listRoles(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Get a role by ID
+ */
+export declare function getRole(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Get a role by name
+ */
+export declare function getRoleByName(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Create a new role
+ */
+export declare function createRole(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Update a role by ID
+ */
+export declare function updateRole(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Update a role by name
+ */
+export declare function updateRoleByName(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Replace a role by ID
+ */
+export declare function replaceRole(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Replace a role by name
+ */
+export declare function replaceRoleByName(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Delete a role by ID
+ */
+export declare function deleteRole(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Delete a role by name
+ */
+export declare function deleteRoleByName(this: IExecuteFunctions): Promise<INodeExecutionData[]>;

package/dist/nodes/ArubaClearPass/methods/PolicyElements/Role.methods.js

@@ -0,0 +1,298 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listRoles = listRoles;
+exports.getRole = getRole;
+exports.getRoleByName = getRoleByName;
+exports.createRole = createRole;
+exports.updateRole = updateRole;
+exports.updateRoleByName = updateRoleByName;
+exports.replaceRole = replaceRole;
+exports.replaceRoleByName = replaceRoleByName;
+exports.deleteRole = deleteRole;
+exports.deleteRoleByName = deleteRoleByName;
+// methods/PolicyElements/Role.methods.ts
+const n8n_workflow_1 = require("n8n-workflow");
+const apiRequest_1 = require("../../helpers/apiRequest");
+const responseFormatter_1 = require("../../helpers/responseFormatter");
+/**
+ * List all roles
+ */
+async function listRoles() {
+    try {
+        const returnAll = this.getNodeParameter('returnAll', 0);
+        const filters = this.getNodeParameter('filters', 0, {});
+        const endpoint = '/role';
+        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 listRoles';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Get a role by ID
+ */
+async function getRole() {
+    try {
+        const roleId = this.getNodeParameter('roleId', 0);
+        const endpoint = `/role/${roleId}`;
+        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 getRole';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Get a role by name
+ */
+async function getRoleByName() {
+    try {
+        const name = this.getNodeParameter('name', 0);
+        const endpoint = `/role/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 getRoleByName';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Create a new role
+ */
+async function createRole() {
+    try {
+        const body = {};
+        // Add required fields
+        body.name = this.getNodeParameter('name', 0);
+        // Add optional fields
+        const description = this.getNodeParameter('description', 0, '');
+        if (description) {
+            body.description = description;
+        }
+        const endpoint = '/role';
+        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 createRole';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Update a role by ID
+ */
+async function updateRole() {
+    try {
+        const roleId = this.getNodeParameter('roleId', 0);
+        const updateFields = this.getNodeParameter('updateFields', 0, {});
+        if (!Object.keys(updateFields).length) {
+            throw new Error('Please specify at least one field to update');
+        }
+        const endpoint = `/role/${roleId}`;
+        const responseData = await apiRequest_1.apiRequest.call(this, 'PATCH', endpoint, updateFields);
+        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 updateRole';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Update a role by name
+ */
+async function updateRoleByName() {
+    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 endpoint = `/role/name/${name}`;
+        const responseData = await apiRequest_1.apiRequest.call(this, 'PATCH', endpoint, updateFields);
+        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 updateRoleByName';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Replace a role by ID
+ */
+async function replaceRole() {
+    try {
+        const roleId = this.getNodeParameter('roleId', 0);
+        const body = {};
+        // Add required fields
+        body.name = this.getNodeParameter('name', 0);
+        // Add optional fields
+        const description = this.getNodeParameter('description', 0, '');
+        if (description) {
+            body.description = description;
+        }
+        const endpoint = `/role/${roleId}`;
+        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 replaceRole';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Replace a role by name
+ */
+async function replaceRoleByName() {
+    try {
+        const name = this.getNodeParameter('name', 0);
+        const body = {};
+        // Add required fields
+        body.name = this.getNodeParameter('name', 0);
+        // Add optional fields
+        const description = this.getNodeParameter('description', 0, '');
+        if (description) {
+            body.description = description;
+        }
+        const endpoint = `/role/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 replaceRoleByName';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Delete a role by ID
+ */
+async function deleteRole() {
+    try {
+        const roleId = this.getNodeParameter('roleId', 0);
+        const endpoint = `/role/${roleId}`;
+        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 deleteRole';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Delete a role by name
+ */
+async function deleteRoleByName() {
+    try {
+        const name = this.getNodeParameter('name', 0);
+        const endpoint = `/role/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 deleteRoleByName';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}