n8n-nodes-netbox/dist/nodes/NetBox/methods/virtualization/vm-interfaces/vm-interfaces.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.listVMInterfaces = listVMInterfaces;
exports.getVMInterface = getVMInterface;
exports.createVMInterface = createVMInterface;
exports.updateVMInterface = updateVMInterface;
exports.deleteVMInterface = deleteVMInterface;
const apiRequest_1 = require("../../../helpers/apiRequest");
const responseFormatter_1 = require("../../../helpers/responseFormatter");
const resourceLookup_1 = require("../../../helpers/resourceLookup");
async function listVMInterfaces() {
    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/virtualization/interfaces/', {}, 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/virtualization/interfaces/', {}, qs);
        return responseFormatter_1.formatResponse.call(this, response);
    }
}
async function getVMInterface() {
    const vmInterfaceId = this.getNodeParameter('vmInterfaceId', 0);
    try {
        const endpoint = `/api/virtualization/interfaces/${vmInterfaceId}/`;
        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 VM interface: ${error.message}`);
    }
}
async function createVMInterface() {
    const virtual_machine = this.getNodeParameter('virtual_machine', 0);
    const name = this.getNodeParameter('name', 0);
    const type = this.getNodeParameter('type', 0);
    const additionalFields = this.getNodeParameter('additionalFields', 0);
    const body = {
        virtual_machine,
        name,
        type,
    };
    try {
        // Handle virtual machine lookup for main parameter
        if (virtual_machine && isNaN(Number(virtual_machine))) {
            try {
                body.virtual_machine = await resourceLookup_1.lookupResourceByName.call(this, 'virtual-machines', virtual_machine, 'virtualization');
            }
            catch (error) {
                throw new Error(`Virtual Machine lookup failed: ${error.message}`);
            }
        }
        else {
            body.virtual_machine = virtual_machine;
        }
        // Process additional fields that need lookup
        if (additionalFields.parent && isNaN(Number(additionalFields.parent))) {
            try {
                // Look up parent interface by name within the same VM
                const vmId = body.virtual_machine;
                const interfaceEndpoint = '/api/virtualization/interfaces/';
                const query = {
                    virtual_machine_id: vmId,
                    name: additionalFields.parent
                };
                const response = await apiRequest_1.apiRequest.call(this, 'GET', interfaceEndpoint, {}, query);
                if (!response.results || response.results.length === 0) {
                    throw new Error(`Parent interface "${additionalFields.parent}" not found on this VM`);
                }
                additionalFields.parent = response.results[0].id;
            }
            catch (error) {
                throw new Error(`Parent Interface lookup failed: ${error.message}`);
            }
        }
        if (additionalFields.bridge && isNaN(Number(additionalFields.bridge))) {
            try {
                // Look up bridge interface by name within the same VM
                const vmId = body.virtual_machine;
                const interfaceEndpoint = '/api/virtualization/interfaces/';
                const query = {
                    virtual_machine_id: vmId,
                    name: additionalFields.bridge
                };
                const response = await apiRequest_1.apiRequest.call(this, 'GET', interfaceEndpoint, {}, query);
                if (!response.results || response.results.length === 0) {
                    throw new Error(`Bridge interface "${additionalFields.bridge}" not found on this VM`);
                }
                additionalFields.bridge = response.results[0].id;
            }
            catch (error) {
                throw new Error(`Bridge Interface lookup failed: ${error.message}`);
            }
        }
        if (additionalFields.untagged_vlan && isNaN(Number(additionalFields.untagged_vlan))) {
            try {
                additionalFields.untagged_vlan = await resourceLookup_1.lookupResourceByName.call(this, 'vlans', additionalFields.untagged_vlan, 'ipam');
            }
            catch (error) {
                throw new Error(`Untagged VLAN lookup failed: ${error.message}`);
            }
        }
        // Process tagged VLANs if they're provided as a string
        if (additionalFields.tagged_vlans && typeof additionalFields.tagged_vlans === 'string') {
            try {
                const vlanIds = [];
                const vlanNames = additionalFields.tagged_vlans.split(',').map((vlan) => vlan.trim());
                for (const vlanName of vlanNames) {
                    if (!isNaN(Number(vlanName))) {
                        vlanIds.push(Number(vlanName));
                    }
                    else {
                        const vlanId = await resourceLookup_1.lookupResourceByName.call(this, 'vlans', vlanName, 'ipam');
                        vlanIds.push(vlanId);
                    }
                }
                additionalFields.tagged_vlans = vlanIds;
            }
            catch (error) {
                throw new Error(`Tagged VLAN lookup failed: ${error.message}`);
            }
        }
        if (additionalFields.vrf && isNaN(Number(additionalFields.vrf))) {
            try {
                additionalFields.vrf = await resourceLookup_1.lookupResourceByName.call(this, 'vrfs', additionalFields.vrf, 'ipam');
            }
            catch (error) {
                throw new Error(`VRF 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/virtualization/interfaces/';
        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 VM interface: ${error.message}`);
    }
}
async function updateVMInterface() {
    const vmInterfaceId = this.getNodeParameter('vmInterfaceId', 0);
    const updateFields = this.getNodeParameter('updateFields', 0);
    try {
        // Process fields that need lookup
        if (updateFields.virtual_machine && isNaN(Number(updateFields.virtual_machine))) {
            try {
                updateFields.virtual_machine = await resourceLookup_1.lookupResourceByName.call(this, 'virtual-machines', updateFields.virtual_machine, 'virtualization');
            }
            catch (error) {
                throw new Error(`Virtual Machine lookup failed: ${error.message}`);
            }
        }
        // Get the current interface to determine VM for parent/bridge lookups
        let vmId = updateFields.virtual_machine;
        if (!vmId) {
            try {
                const currentInterface = await apiRequest_1.apiRequest.call(this, 'GET', `/api/virtualization/interfaces/${vmInterfaceId}/`);
                vmId = currentInterface.virtual_machine.id;
            }
            catch (error) {
                throw new Error(`Failed to get current interface details: ${error.message}`);
            }
        }
        if (updateFields.parent && isNaN(Number(updateFields.parent))) {
            try {
                // Look up parent interface by name within the same VM
                const interfaceEndpoint = '/api/virtualization/interfaces/';
                const query = {
                    virtual_machine_id: vmId,
                    name: updateFields.parent
                };
                const response = await apiRequest_1.apiRequest.call(this, 'GET', interfaceEndpoint, {}, query);
                if (!response.results || response.results.length === 0) {
                    throw new Error(`Parent interface "${updateFields.parent}" not found on this VM`);
                }
                updateFields.parent = response.results[0].id;
            }
            catch (error) {
                throw new Error(`Parent Interface lookup failed: ${error.message}`);
            }
        }
        if (updateFields.bridge && isNaN(Number(updateFields.bridge))) {
            try {
                // Look up bridge interface by name within the same VM
                const interfaceEndpoint = '/api/virtualization/interfaces/';
                const query = {
                    virtual_machine_id: vmId,
                    name: updateFields.bridge
                };
                const response = await apiRequest_1.apiRequest.call(this, 'GET', interfaceEndpoint, {}, query);
                if (!response.results || response.results.length === 0) {
                    throw new Error(`Bridge interface "${updateFields.bridge}" not found on this VM`);
                }
                updateFields.bridge = response.results[0].id;
            }
            catch (error) {
                throw new Error(`Bridge Interface lookup failed: ${error.message}`);
            }
        }
        if (updateFields.untagged_vlan && isNaN(Number(updateFields.untagged_vlan))) {
            try {
                updateFields.untagged_vlan = await resourceLookup_1.lookupResourceByName.call(this, 'vlans', updateFields.untagged_vlan, 'ipam');
            }
            catch (error) {
                throw new Error(`Untagged VLAN lookup failed: ${error.message}`);
            }
        }
        // Process tagged VLANs if they're provided as a string
        if (updateFields.tagged_vlans && typeof updateFields.tagged_vlans === 'string') {
            try {
                const vlanIds = [];
                const vlanNames = updateFields.tagged_vlans.split(',').map((vlan) => vlan.trim());
                for (const vlanName of vlanNames) {
                    if (!isNaN(Number(vlanName))) {
                        vlanIds.push(Number(vlanName));
                    }
                    else {
                        const vlanId = await resourceLookup_1.lookupResourceByName.call(this, 'vlans', vlanName, 'ipam');
                        vlanIds.push(vlanId);
                    }
                }
                updateFields.tagged_vlans = vlanIds;
            }
            catch (error) {
                throw new Error(`Tagged VLAN lookup failed: ${error.message}`);
            }
        }
        if (updateFields.vrf && isNaN(Number(updateFields.vrf))) {
            try {
                updateFields.vrf = await resourceLookup_1.lookupResourceByName.call(this, 'vrfs', updateFields.vrf, 'ipam');
            }
            catch (error) {
                throw new Error(`VRF 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/virtualization/interfaces/${vmInterfaceId}/`;
        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 VM interface: ${error.message}`);
    }
}
async function deleteVMInterface() {
    const vmInterfaceId = this.getNodeParameter('vmInterfaceId', 0);
    try {
        const endpoint = `/api/virtualization/interfaces/${vmInterfaceId}/`;
        await apiRequest_1.apiRequest.call(this, 'DELETE', endpoint);
        return [{ json: { success: true } }];
    }
    catch (error) {
        throw new Error(`Failed to delete VM interface: ${error.message}`);
    }
}