@panoptic-it-solutions/n8n-nodes-datto-rmm/dist/nodes/DattoRmm/helpers/deviceFilter.js

n8n node for Datto RMM integration

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.applyAdvancedFilters = applyAdvancedFilters;
exports.validateFilterConditions = validateFilterConditions;
exports.applyFieldSelection = applyFieldSelection;
function getNestedValue(obj, path) {
    return path.split('.').reduce((current, key) => {
        return current && current[key] !== undefined ? current[key] : undefined;
    }, obj);
}
function evaluateCondition(device, condition) {
    const { field, operator, value, numericValue, booleanValue } = condition;
    const fieldValue = getNestedValue(device, field);
    if (fieldValue === null || fieldValue === undefined) {
        switch (operator) {
            case 'isEmpty':
                return true;
            case 'isNotEmpty':
                return false;
            default:
                return false;
        }
    }
    const fieldStr = String(fieldValue).toLowerCase();
    const compareStr = String(value || '').toLowerCase();
    switch (operator) {
        case 'equals':
            if (typeof fieldValue === 'boolean') {
                return fieldValue === booleanValue;
            }
            return fieldStr === compareStr;
        case 'contains':
            return fieldStr.includes(compareStr);
        case 'startsWith':
            return fieldStr.startsWith(compareStr);
        case 'endsWith':
            return fieldStr.endsWith(compareStr);
        case 'notEquals':
            if (typeof fieldValue === 'boolean') {
                return fieldValue !== booleanValue;
            }
            return fieldStr !== compareStr;
        case 'notContains':
            return !fieldStr.includes(compareStr);
        case 'isEmpty':
            return fieldStr === '' || fieldStr === 'null' || fieldStr === 'undefined';
        case 'isNotEmpty':
            return fieldStr !== '' && fieldStr !== 'null' && fieldStr !== 'undefined';
        case 'greaterThan': {
            const numValue = Number(fieldValue);
            return !isNaN(numValue) && numValue > (numericValue || 0);
        }
        case 'lessThan': {
            const numValueLT = Number(fieldValue);
            return !isNaN(numValueLT) && numValueLT < (numericValue || 0);
        }
        case 'greaterThanOrEqual': {
            const numValueGTE = Number(fieldValue);
            return !isNaN(numValueGTE) && numValueGTE >= (numericValue || 0);
        }
        case 'lessThanOrEqual': {
            const numValueLTE = Number(fieldValue);
            return !isNaN(numValueLTE) && numValueLTE <= (numericValue || 0);
        }
        case 'regex': {
            try {
                const regex = new RegExp(value || '', 'i');
                return regex.test(fieldStr);
            }
            catch {
                return false;
            }
        }
        default:
            return false;
    }
}
function applyAdvancedFilters(devices, filterConditions, filterLogic = 'AND') {
    if (!filterConditions || filterConditions.length === 0) {
        return devices;
    }
    return devices.filter((device) => {
        const results = filterConditions.map((condition) => evaluateCondition(device, condition));
        if (filterLogic === 'AND') {
            return results.every((result) => result);
        }
        else {
            return results.some((result) => result);
        }
    });
}
function validateFilterConditions(conditions) {
    if (!Array.isArray(conditions)) {
        return [];
    }
    return conditions
        .filter((condition) => condition && condition.field && condition.operator)
        .map((condition) => ({
        field: condition.field,
        operator: condition.operator,
        value: condition.value,
        numericValue: condition.numericValue,
        booleanValue: condition.booleanValue,
    }));
}
function applyFieldSelection(devices, resourceMapper) {
    if (!resourceMapper || !resourceMapper.value || !Array.isArray(resourceMapper.value)) {
        return devices;
    }
    const selectedFields = resourceMapper.value.map((field) => field.id);
    if (selectedFields.length === 0) {
        return devices;
    }
    return devices.map((device) => {
        const filteredDevice = {};
        selectedFields.forEach((fieldPath) => {
            const value = getNestedValue(device, fieldPath);
            if (value !== undefined) {
                setNestedValue(filteredDevice, fieldPath, value);
            }
        });
        return filteredDevice;
    });
}
function setNestedValue(obj, path, value) {
    const keys = path.split('.');
    const lastKey = keys.pop();
    let current = obj;
    for (const key of keys) {
        if (current[key] === undefined) {
            current[key] = {};
        }
        current = current[key];
    }
    current[lastKey] = value;
}
//# sourceMappingURL=deviceFilter.js.map