n8n-nodes-arubaclearpass 1.0.0

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

@@ -0,0 +1,41 @@
+import { IExecuteFunctions, INodeExecutionData } from 'n8n-workflow';
+/**
+ * List all role mappings
+ */
+export declare function listRoleMappings(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Get a role mapping by ID
+ */
+export declare function getRoleMapping(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Get a role mapping by name
+ */
+export declare function getRoleMappingByName(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Create a new role mapping
+ */
+export declare function createRoleMapping(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Update a role mapping by ID
+ */
+export declare function updateRoleMapping(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Update a role mapping by name
+ */
+export declare function updateRoleMappingByName(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Replace a role mapping by ID
+ */
+export declare function replaceRoleMapping(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Replace a role mapping by name
+ */
+export declare function replaceRoleMappingByName(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Delete a role mapping by ID
+ */
+export declare function deleteRoleMapping(this: IExecuteFunctions): Promise<INodeExecutionData[]>;
+/**
+ * Delete a role mapping by name
+ */
+export declare function deleteRoleMappingByName(this: IExecuteFunctions): Promise<INodeExecutionData[]>;

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

@@ -0,0 +1,358 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listRoleMappings = listRoleMappings;
+exports.getRoleMapping = getRoleMapping;
+exports.getRoleMappingByName = getRoleMappingByName;
+exports.createRoleMapping = createRoleMapping;
+exports.updateRoleMapping = updateRoleMapping;
+exports.updateRoleMappingByName = updateRoleMappingByName;
+exports.replaceRoleMapping = replaceRoleMapping;
+exports.replaceRoleMappingByName = replaceRoleMappingByName;
+exports.deleteRoleMapping = deleteRoleMapping;
+exports.deleteRoleMappingByName = deleteRoleMappingByName;
+// methods/PolicyElements/RoleMapping.methods.ts
+const n8n_workflow_1 = require("n8n-workflow");
+const apiRequest_1 = require("../../helpers/apiRequest");
+const responseFormatter_1 = require("../../helpers/responseFormatter");
+/**
+ * List all role mappings
+ */
+async function listRoleMappings() {
+    try {
+        const returnAll = this.getNodeParameter('returnAll', 0);
+        const filters = this.getNodeParameter('filters', 0, {});
+        const endpoint = '/role-mapping';
+        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 listRoleMappings';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Get a role mapping by ID
+ */
+async function getRoleMapping() {
+    try {
+        const roleMappingId = this.getNodeParameter('roleMappingId', 0);
+        const endpoint = `/role-mapping/${roleMappingId}`;
+        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 getRoleMapping';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Get a role mapping by name
+ */
+async function getRoleMappingByName() {
+    try {
+        const name = this.getNodeParameter('name', 0);
+        const endpoint = `/role-mapping/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 getRoleMappingByName';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Create a new role mapping
+ */
+async function createRoleMapping() {
+    try {
+        const body = {};
+        // Add required fields
+        body.name = this.getNodeParameter('name', 0);
+        body.default_role_name = this.getNodeParameter('default_role_name', 0);
+        body.rule_combine_algo = this.getNodeParameter('rule_combine_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 = '/role-mapping';
+        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 createRoleMapping';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Update a role mapping by ID
+ */
+async function updateRoleMapping() {
+    try {
+        const roleMappingId = this.getNodeParameter('roleMappingId', 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 = `/role-mapping/${roleMappingId}`;
+        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 updateRoleMapping';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Update a role mapping by name
+ */
+async function updateRoleMappingByName() {
+    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 = `/role-mapping/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 updateRoleMappingByName';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Replace a role mapping by ID
+ */
+async function replaceRoleMapping() {
+    try {
+        const roleMappingId = this.getNodeParameter('roleMappingId', 0);
+        const body = {};
+        // Add required fields
+        body.name = this.getNodeParameter('name', 0);
+        body.default_role_name = this.getNodeParameter('default_role_name', 0);
+        body.rule_combine_algo = this.getNodeParameter('rule_combine_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 = `/role-mapping/${roleMappingId}`;
+        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 replaceRoleMapping';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Replace a role mapping by name
+ */
+async function replaceRoleMappingByName() {
+    try {
+        const name = this.getNodeParameter('name', 0);
+        const body = {};
+        // Add required fields
+        body.name = this.getNodeParameter('name', 0);
+        body.default_role_name = this.getNodeParameter('default_role_name', 0);
+        body.rule_combine_algo = this.getNodeParameter('rule_combine_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 = `/role-mapping/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 replaceRoleMappingByName';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Delete a role mapping by ID
+ */
+async function deleteRoleMapping() {
+    try {
+        const roleMappingId = this.getNodeParameter('roleMappingId', 0);
+        const endpoint = `/role-mapping/${roleMappingId}`;
+        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 deleteRoleMapping';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}
+/**
+ * Delete a role mapping by name
+ */
+async function deleteRoleMappingByName() {
+    try {
+        const name = this.getNodeParameter('name', 0);
+        const endpoint = `/role-mapping/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 deleteRoleMappingByName';
+        }
+        throw new n8n_workflow_1.NodeApiError(this.getNode(), errorObject);
+    }
+}

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

@@ -0,0 +1,131 @@
+export interface IAttribute {
+    type?: string;
+    name?: string;
+    value?: string;
+}
+export interface IACL {
+    name?: string;
+    type?: 'Ethertype' | 'MAC' | 'Stateless' | 'Session';
+}
+export interface ITacacsCommandArgs {
+    argument?: string;
+    permit_action?: boolean;
+}
+export interface ITacacsCommand {
+    command?: string;
+    permit_unmatched_args?: boolean;
+    command_args?: ITacacsCommandArgs[] | ITacacsCommandArgs;
+}
+export interface ITacacsCommandConfig {
+    service_type?: 'Shell' | 'PIX Shell';
+    permit_unmatched_cmds?: boolean;
+    commands?: ITacacsCommand[] | ITacacsCommand;
+}
+export interface ITacacsServiceParam {
+    privilege_level?: number;
+    services?: string[];
+    authorize_attribute_status?: 'ADD' | 'REPLACE' | 'FAIL';
+    tacacs_command_config?: ITacacsCommandConfig;
+}
+export interface IArubaOSSwitchConfig {
+    captive_portal_profile_name?: string;
+    policy_name?: string;
+    controller_static_role?: string;
+    controller_downloadable_role?: string;
+    vlan_id?: string;
+    vlan_name?: string;
+    vlan_tagged_id?: string;
+    vlan_tagged_name?: string;
+    reauth_period?: string;
+    logoff_period?: string;
+    cached_reauth_period?: string;
+    enable_device_config?: boolean;
+    enable_poe_allocate_by_class?: boolean;
+    poe_priority?: 'low' | 'high' | 'critical';
+    enable_admin_edge_port?: boolean;
+    enable_port_mode?: boolean;
+}
+export interface IMASConfig {
+    captive_portal_profile_name?: string;
+    policer_profile_name?: string;
+    qos_profile_name?: string;
+    voip_profile_name?: string;
+    reauth_interval?: number;
+    vlan_id?: number;
+    acl_list?: IACL[] | IACL;
+}
+export interface IAMCConfig {
+    captive_portal_profile_name?: string;
+    reauth_interval?: number;
+    vlan_id?: number;
+    vlan_name?: string;
+    parameterized_vlan?: string;
+    acl_list?: IACL[] | IACL;
+}
+export interface IAOSCXConfig {
+    role_name?: string;
+    description?: string;
+    captive_portal_name?: string;
+    authentication_mode?: '' | 'client-mode' | 'device-mode' | 'multi-domain-mode';
+    device_traffic_class?: 'None' | 'Voice';
+    session_timeout_type?: 'Static' | 'Parameterized';
+    session_timeout?: string;
+    parameterized_session_timeout?: string;
+    cached_reauth_period?: string;
+    reauth_period_type?: 'Manual' | 'Random' | 'Parameterized';
+    reauth_period?: string;
+    minimum_reauth_period?: string;
+    parameterized_reauth?: string;
+    client_inactivity_timeout_type?: 'Value' | 'None' | 'Parameterized';
+    client_inactivity_timeout?: string;
+    parameterized_client_inactivity_timeout?: string;
+    allowed_vlan_ids_trunk?: string;
+    allowed_vlan_names_trunk?: string;
+    parameterized_allowed_vlan_type?: 'Id' | 'Name';
+    parameterized_allowed_vlan?: string;
+    native_trunk_vlan_type?: 'Id' | 'Name' | 'Parameterized';
+    native_trunk_vlan_id?: string;
+    native_trunk_vlan_name?: string;
+    parameterized_native_trunk_vlan?: string;
+    access_vlan_type?: 'Id' | 'Name' | 'Parameterized';
+    access_vlan_id?: string;
+    access_vlan_name?: string;
+    parameterized_access_vlan?: string;
+    gateway_zone?: string;
+    secondary_role_type?: 'None' | 'Static' | 'Dynamic';
+    gateway_static_role?: string;
+    gateway_downloadable_role?: string;
+    mtu?: string;
+    trust_mode?: '' | 'none' | 'cos' | 'dscp';
+    poe_priority?: '' | 'low' | 'high' | 'critical';
+    private_vlan_port_type?: '' | 'promiscuous' | 'secondary';
+    policy_name?: string;
+}
+export interface IDURConfig {
+    config_mode?: 'Standard' | 'Advanced';
+    product?: 'AOS-CX' | 'Mobility Controller' | 'ArubaOS-Switch' | 'Mobility Access Switch';
+    aruba_os_switch_config?: IArubaOSSwitchConfig;
+    mobility_access_switch_config?: IMASConfig;
+    mobility_controller_config?: IAMCConfig;
+    aos_cx_config?: IAOSCXConfig;
+}
+export interface IEnforcementProfile {
+    id?: number;
+    name: string;
+    description?: string;
+    type: 'RADIUS' | 'TACACS' | 'SNMP' | 'Application' | 'Agent' | 'CLI' | 'HTTP' | 'RADIUS_DynAuthZ' | 'Post_Authentication' | 'Aruba_DUR';
+    agent_template?: 'Agent' | 'AgentScript';
+    post_auth_template?: 'EntityUpdate' | 'SessionRestriction' | 'SessionNotify';
+    radius_dyn_authz_template?: string;
+    action?: 'Accept' | 'Reject' | 'Drop';
+    device_group_list?: string[];
+    attributes?: IAttribute[] | IAttribute;
+    tacacs_service_params?: ITacacsServiceParam;
+    dur_config?: IDURConfig;
+}
+export interface IEnforcementProfileCreate extends IEnforcementProfile {
+}
+export interface IEnforcementProfileUpdate extends Partial<IEnforcementProfile> {
+}
+export interface IEnforcementProfileReplace extends IEnforcementProfile {
+}

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,55 @@
+export interface IDevice {
+    id?: number;
+    mac: string;
+    mac_auth?: boolean;
+    enabled?: boolean;
+    username?: string;
+    password?: string;
+    role_id?: number;
+    role_name?: string;
+    start_time?: string;
+    expire_time?: string;
+    current_state?: 'active' | 'disabled' | 'expired' | 'pending';
+    visitor_name?: string;
+    sponsor_name?: string;
+    sponsor_profile?: string;
+    sponsor_profile_name?: string;
+    notes?: string;
+    source?: string;
+    create_time?: string;
+    [key: string]: any;
+}
+export interface IDeviceCreate {
+    mac: string;
+    role_id: number;
+    role_name?: string;
+    enabled?: boolean;
+    start_time?: string;
+    expire_time?: string;
+    visitor_name?: string;
+    sponsor_name?: string;
+    sponsor_profile?: string;
+    sponsor_profile_name?: string;
+    notes?: string;
+    source?: string;
+    create_time?: string;
+    [key: string]: any;
+}
+export interface IDeviceUpdate extends Partial<IDeviceCreate> {
+}
+export interface IDeviceReplace {
+    mac: string;
+    role_id: number;
+    role_name?: string;
+    enabled?: boolean;
+    start_time?: string;
+    expire_time?: string;
+    visitor_name?: string;
+    sponsor_name?: string;
+    sponsor_profile?: string;
+    sponsor_profile_name?: string;
+    notes?: string;
+    source?: string;
+    create_time?: string;
+    [key: string]: any;
+}

package/dist/nodes/ArubaClearPass/types/Identities/Device.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nodes/ArubaClearPass/types/Identities/Endpoint.types.d.ts

@@ -0,0 +1,12 @@
+import { IDataObject } from 'n8n-workflow';
+export interface IEndpoint {
+    id?: number;
+    mac_address: string;
+    description?: string;
+    status?: string;
+    randomized_mac?: boolean;
+    device_insight_tags?: string;
+    attributes?: IDataObject;
+    added_at?: string;
+    updated_at?: string;
+}

package/dist/nodes/ArubaClearPass/types/Identities/Endpoint.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/nodes/ArubaClearPass/types/Identities/GuestUser.types.d.ts

@@ -0,0 +1,31 @@
+export interface IGuestUser {
+    id?: number;
+    username: string;
+    password?: string;
+    role_id: number;
+    role_name?: string;
+    enabled: boolean;
+    start_time: string;
+    expire_time: string;
+    create_time?: string;
+    sponsor_name: string;
+    sponsor_profile: string;
+    sponsor_email?: string;
+    visitor_name?: string;
+    visitor_company?: string;
+    visitor_phone?: string;
+    email?: string;
+    mac?: string;
+    notes?: string;
+    simultaneous_use?: number;
+    do_expire?: number;
+    current_state?: string;
+}
+export interface IGuestUserCreate extends Omit<IGuestUser, 'id' | 'role_name' | 'current_state'> {
+    password: string;
+}
+export interface IGuestUserUpdate extends Partial<IGuestUserCreate> {
+}
+export interface IGuestUserReplace extends Omit<IGuestUserCreate, 'id'> {
+    id?: number;
+}

package/dist/nodes/ArubaClearPass/types/Identities/GuestUser.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });