n8n-nodes-netbox/dist/nodes/NetBox/methods/wireless/wireless-lans/wireless-lans.methods.js

n8n community node for NetBox API integration with comprehensive DCIM, IPAM, Virtualization, Circuits, Wireless, and data center management operations

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.listWirelessLANs = listWirelessLANs;
exports.getWirelessLAN = getWirelessLAN;
exports.createWirelessLAN = createWirelessLAN;
exports.updateWirelessLAN = updateWirelessLAN;
exports.deleteWirelessLAN = deleteWirelessLAN;
const apiRequest_1 = require("../../../helpers/apiRequest");
const responseFormatter_1 = require("../../../helpers/responseFormatter");
const resourceLookup_1 = require("../../../helpers/resourceLookup");
async function listWirelessLANs() {
    const returnAll = this.getNodeParameter('returnAll', 0);
    const filters = this.getNodeParameter('filters', 0, {});
    const qs = {};
    Object.assign(qs, filters);
    if (returnAll) {
        const response = await apiRequest_1.apiRequestAllItems.call(this, 'GET', '/api/wireless/wireless-lans/', {}, qs);
        return responseFormatter_1.formatResponse.call(this, response);
    }
    else {
        const limit = this.getNodeParameter('limit', 0);
        qs.limit = limit;
        const response = await apiRequest_1.apiRequest.call(this, 'GET', '/api/wireless/wireless-lans/', {}, qs);
        return responseFormatter_1.formatResponse.call(this, response);
    }
}
async function getWirelessLAN() {
    const wirelessLANId = this.getNodeParameter('wirelessLANId', 0);
    try {
        const endpoint = `/api/wireless/wireless-lans/${wirelessLANId}/`;
        const response = await apiRequest_1.apiRequest.call(this, 'GET', endpoint);
        return responseFormatter_1.formatResponse.call(this, response);
    }
    catch (error) {
        throw new Error(`Failed to get wireless LAN: ${error.message}`);
    }
}
async function createWirelessLAN() {
    const ssid = this.getNodeParameter('ssid', 0);
    const additionalFields = this.getNodeParameter('additionalFields', 0);
    const body = {
        ssid,
    };
    try {
        // Process additional fields that need lookup
        if (additionalFields.group && isNaN(Number(additionalFields.group))) {
            try {
                additionalFields.group = await resourceLookup_1.lookupResourceByName.call(this, 'wireless-lan-groups', additionalFields.group, 'wireless');
            }
            catch (error) {
                throw new Error(`Wireless LAN group lookup failed: ${error.message}`);
            }
        }
        if (additionalFields.vlan && isNaN(Number(additionalFields.vlan))) {
            try {
                // Try to look up VLAN by name first, then by VID
                const vlanValue = additionalFields.vlan;
                let vlanId;
                // Check if it's a numeric VID
                if (!isNaN(Number(vlanValue))) {
                    // Look up by VID
                    const vlanEndpoint = '/api/ipam/vlans/';
                    const query = { vid: Number(vlanValue) };
                    const response = await apiRequest_1.apiRequest.call(this, 'GET', vlanEndpoint, {}, query);
                    if (response.results && response.results.length > 0) {
                        vlanId = response.results[0].id;
                    }
                    else {
                        throw new Error(`VLAN with VID ${vlanValue} not found`);
                    }
                }
                else {
                    // Look up by name
                    vlanId = await resourceLookup_1.lookupResourceByName.call(this, 'vlans', vlanValue, 'ipam');
                }
                additionalFields.vlan = vlanId;
            }
            catch (error) {
                throw new Error(`VLAN lookup failed: ${error.message}`);
            }
        }
        if (additionalFields.tenant && isNaN(Number(additionalFields.tenant))) {
            try {
                additionalFields.tenant = await resourceLookup_1.lookupResourceByName.call(this, 'tenants', additionalFields.tenant, 'tenancy');
            }
            catch (error) {
                throw new Error(`Tenant lookup failed: ${error.message}`);
            }
        }
        // Process tags if they're provided as a string
        if (additionalFields.tags && typeof additionalFields.tags === 'string') {
            try {
                const tagIds = [];
                const tagNames = additionalFields.tags.split(',').map((tag) => tag.trim());
                for (const tagName of tagNames) {
                    if (!isNaN(Number(tagName))) {
                        tagIds.push(Number(tagName));
                    }
                    else {
                        const tagId = await resourceLookup_1.lookupResourceByName.call(this, 'tags', tagName, 'extras');
                        tagIds.push(tagId);
                    }
                }
                additionalFields.tags = tagIds;
            }
            catch (error) {
                throw new Error(`Tag lookup failed: ${error.message}`);
            }
        }
        // Parse custom_fields if it's a string
        if (additionalFields.custom_fields && typeof additionalFields.custom_fields === 'string') {
            try {
                additionalFields.custom_fields = JSON.parse(additionalFields.custom_fields);
            }
            catch (e) {
                throw new Error(`Invalid JSON in custom_fields: ${e.message}`);
            }
        }
        // Add all additional fields to the request body
        Object.assign(body, additionalFields);
        const endpoint = '/api/wireless/wireless-lans/';
        const response = await apiRequest_1.apiRequest.call(this, 'POST', endpoint, body);
        return responseFormatter_1.formatResponse.call(this, response);
    }
    catch (error) {
        throw new Error(`Failed to create wireless LAN: ${error.message}`);
    }
}
async function updateWirelessLAN() {
    const wirelessLANId = this.getNodeParameter('wirelessLANId', 0);
    const updateFields = this.getNodeParameter('updateFields', 0);
    try {
        // Process fields that need lookup
        if (updateFields.group && isNaN(Number(updateFields.group))) {
            try {
                updateFields.group = await resourceLookup_1.lookupResourceByName.call(this, 'wireless-lan-groups', updateFields.group, 'wireless');
            }
            catch (error) {
                throw new Error(`Wireless LAN group lookup failed: ${error.message}`);
            }
        }
        if (updateFields.vlan && isNaN(Number(updateFields.vlan))) {
            try {
                // Try to look up VLAN by name first, then by VID
                const vlanValue = updateFields.vlan;
                let vlanId;
                // Check if it's a numeric VID
                if (!isNaN(Number(vlanValue))) {
                    // Look up by VID
                    const vlanEndpoint = '/api/ipam/vlans/';
                    const query = { vid: Number(vlanValue) };
                    const response = await apiRequest_1.apiRequest.call(this, 'GET', vlanEndpoint, {}, query);
                    if (response.results && response.results.length > 0) {
                        vlanId = response.results[0].id;
                    }
                    else {
                        throw new Error(`VLAN with VID ${vlanValue} not found`);
                    }
                }
                else {
                    // Look up by name
                    vlanId = await resourceLookup_1.lookupResourceByName.call(this, 'vlans', vlanValue, 'ipam');
                }
                updateFields.vlan = vlanId;
            }
            catch (error) {
                throw new Error(`VLAN lookup failed: ${error.message}`);
            }
        }
        if (updateFields.tenant && isNaN(Number(updateFields.tenant))) {
            try {
                updateFields.tenant = await resourceLookup_1.lookupResourceByName.call(this, 'tenants', updateFields.tenant, 'tenancy');
            }
            catch (error) {
                throw new Error(`Tenant lookup failed: ${error.message}`);
            }
        }
        // Process tags if they're provided as a string
        if (updateFields.tags && typeof updateFields.tags === 'string') {
            try {
                const tagIds = [];
                const tagNames = updateFields.tags.split(',').map((tag) => tag.trim());
                for (const tagName of tagNames) {
                    if (!isNaN(Number(tagName))) {
                        tagIds.push(Number(tagName));
                    }
                    else {
                        const tagId = await resourceLookup_1.lookupResourceByName.call(this, 'tags', tagName, 'extras');
                        tagIds.push(tagId);
                    }
                }
                updateFields.tags = tagIds;
            }
            catch (error) {
                throw new Error(`Tag lookup failed: ${error.message}`);
            }
        }
        // Parse custom_fields if it's a string
        if (updateFields.custom_fields && typeof updateFields.custom_fields === 'string') {
            try {
                updateFields.custom_fields = JSON.parse(updateFields.custom_fields);
            }
            catch (e) {
                throw new Error(`Invalid JSON in custom_fields: ${e.message}`);
            }
        }
        const endpoint = `/api/wireless/wireless-lans/${wirelessLANId}/`;
        const response = await apiRequest_1.apiRequest.call(this, 'PATCH', endpoint, updateFields);
        return responseFormatter_1.formatResponse.call(this, response);
    }
    catch (error) {
        throw new Error(`Failed to update wireless LAN: ${error.message}`);
    }
}
async function deleteWirelessLAN() {
    const wirelessLANId = this.getNodeParameter('wirelessLANId', 0);
    try {
        const endpoint = `/api/wireless/wireless-lans/${wirelessLANId}/`;
        await apiRequest_1.apiRequest.call(this, 'DELETE', endpoint);
        return [{ json: { success: true } }];
    }
    catch (error) {
        throw new Error(`Failed to delete wireless LAN: ${error.message}`);
    }
}