n8n-nodes-netbox/dist/nodes/NetBox/methods/users/tokens/tokens.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.listTokens = listTokens;
exports.getToken = getToken;
exports.createToken = createToken;
exports.updateToken = updateToken;
exports.deleteToken = deleteToken;
const apiRequest_1 = require("../../../helpers/apiRequest");
const responseFormatter_1 = require("../../../helpers/responseFormatter");
const resourceLookup_1 = require("../../../helpers/resourceLookup");
async function listTokens() {
    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/users/tokens/', {}, 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/users/tokens/', {}, qs);
        return responseFormatter_1.formatResponse.call(this, response);
    }
}
async function getToken() {
    const tokenId = this.getNodeParameter('tokenId', 0);
    try {
        const endpoint = `/api/users/tokens/${tokenId}/`;
        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 token: ${error.message}`);
    }
}
async function createToken() {
    const user = this.getNodeParameter('tokenUser', 0);
    const additionalFields = this.getNodeParameter('additionalFields', 0);
    const body = {};
    try {
        // Process user field - lookup by username if not a number
        if (user && !isNaN(Number(user))) {
            body.user = Number(user);
        }
        else if (user) {
            try {
                body.user = await resourceLookup_1.lookupResourceByName.call(this, 'users', user, 'users');
            }
            catch (error) {
                throw new Error(`User 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}`);
            }
        }
        // Map description field to API field name
        if (additionalFields.tokenDescription) {
            additionalFields.description = additionalFields.tokenDescription;
            delete additionalFields.tokenDescription;
        }
        Object.assign(body, additionalFields);
        const endpoint = '/api/users/tokens/';
        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 token: ${error.message}`);
    }
}
async function updateToken() {
    const tokenId = this.getNodeParameter('tokenId', 0);
    const updateFields = this.getNodeParameter('updateFields', 0);
    try {
        // Process user field - lookup by username if not a number
        if (updateFields.tokenUser && !isNaN(Number(updateFields.tokenUser))) {
            updateFields.user = Number(updateFields.tokenUser);
            delete updateFields.tokenUser;
        }
        else if (updateFields.tokenUser) {
            try {
                updateFields.user = await resourceLookup_1.lookupResourceByName.call(this, 'users', updateFields.tokenUser, 'users');
                delete updateFields.tokenUser;
            }
            catch (error) {
                throw new Error(`User 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}`);
            }
        }
        // Map description field to API field name
        if (updateFields.tokenDescription) {
            updateFields.description = updateFields.tokenDescription;
            delete updateFields.tokenDescription;
        }
        const endpoint = `/api/users/tokens/${tokenId}/`;
        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 token: ${error.message}`);
    }
}
async function deleteToken() {
    const tokenId = this.getNodeParameter('tokenId', 0);
    try {
        const endpoint = `/api/users/tokens/${tokenId}/`;
        await apiRequest_1.apiRequest.call(this, 'DELETE', endpoint);
        return [{ json: { success: true } }];
    }
    catch (error) {
        throw new Error(`Failed to delete token: ${error.message}`);
    }
}