n8n-nodes-mautic-advanced
Version:
Enhanced n8n node for Mautic with comprehensive API coverage including tags, campaigns, categories, and advanced contact management
187 lines (186 loc) • 7.17 kB
JavaScript
;
Object.defineProperty(exports, "__esModule", { value: true });
exports.convertNumericStrings = exports.createBatchSuccessResponse = exports.processBatchIds = exports.buildQueryFromOptions = exports.validateJsonParameter = exports.processContactFields = exports.wrapSingleItem = exports.processSimpleResponse = void 0;
const GenericFunctions_1 = require("../GenericFunctions");
// Process simple response data extraction
function processSimpleResponse(responseData, simple, dataPath) {
if (!simple || !dataPath) {
return responseData;
}
const pathParts = dataPath.split('.');
let result = responseData;
for (const part of pathParts) {
result = result?.[part];
}
return result?.fields?.all || result;
}
exports.processSimpleResponse = processSimpleResponse;
// Ensure single item responses are wrapped in arrays for consistency
function wrapSingleItem(data) {
if (Array.isArray(data)) {
return data;
}
return data ? [data] : [];
}
exports.wrapSingleItem = wrapSingleItem;
// Process contact fields data for simple mode
function processContactFields(responseData, options, fieldsToReturn) {
const sourceData = Array.isArray(responseData) ? responseData : [responseData];
const filterFields = fieldsToReturn ?? options.fieldsToReturn;
if (options.rawData === true) {
if (Array.isArray(filterFields) && filterFields.length > 0) {
return sourceData.map((item) => filterContactFields(item, item, filterFields));
}
return sourceData;
}
const processedData = sourceData.map((item) => {
const all = item.fields?.all;
if (!all)
return item;
return { id: item.id, owner: item.owner ?? null, ...all };
});
if (Array.isArray(filterFields) && filterFields.length > 0) {
return processedData.map((item, index) => filterContactFields(item, sourceData[index], filterFields));
}
return processedData;
}
exports.processContactFields = processContactFields;
function filterContactFields(preferredSource, originalSource, filterFields) {
const filtered = {};
for (const field of filterFields) {
const preferredLookup = readContactField(preferredSource, field);
const lookup = preferredLookup.found
? preferredLookup
: readContactField(originalSource, field);
if (lookup.found && lookup.value !== undefined) {
filtered[field] = lookup.value;
}
}
return filtered;
}
function readContactField(source, field) {
if (!source) {
return { found: false };
}
if (Object.prototype.hasOwnProperty.call(source, field)) {
return { found: true, value: source[field] };
}
const rawField = readRawContactFieldAlias(source, field);
if (rawField.found) {
return rawField;
}
const fieldsAll = source.fields?.all;
if (fieldsAll && Object.prototype.hasOwnProperty.call(fieldsAll, field)) {
return { found: true, value: fieldsAll[field] };
}
return { found: false };
}
function readRawContactFieldAlias(source, field) {
const rawAliasMap = {
date_added: ['dateAdded'],
date_identified: ['dateIdentified'],
date_modified: ['dateModified'],
last_active: ['lastActive'],
};
for (const alias of rawAliasMap[field] || []) {
if (Object.prototype.hasOwnProperty.call(source, alias)) {
return { found: true, value: source[alias] };
}
}
if (field === 'owner_id' && Object.prototype.hasOwnProperty.call(source, 'owner')) {
const owner = source.owner;
if (owner && typeof owner === 'object' && Object.prototype.hasOwnProperty.call(owner, 'id')) {
return { found: true, value: owner.id };
}
return { found: true, value: owner };
}
return { found: false };
}
// Validate and parse JSON input parameters
function validateJsonParameter(context, paramName, itemIndex) {
const jsonString = context.getNodeParameter(paramName, itemIndex);
const parsed = (0, GenericFunctions_1.validateJSON)(jsonString);
if (parsed === undefined) {
throw new Error(`Invalid JSON provided in '${paramName}' parameter`);
}
return parsed;
}
exports.validateJsonParameter = validateJsonParameter;
// Build query parameters from options object
function buildQueryFromOptions(options = {}, additionalParams = {}) {
const query = { ...additionalParams };
if (options.limit)
query.limit = options.limit;
if (options.start)
query.start = options.start;
if (options.orderBy)
query.orderBy = options.orderBy;
if (options.orderByDir)
query.orderByDir = options.orderByDir;
if (options.search)
query.search = options.search;
if (options.publishedOnly !== undefined)
query.publishedOnly = options.publishedOnly;
if (options.minimal !== undefined)
query.minimal = options.minimal;
return query;
}
exports.buildQueryFromOptions = buildQueryFromOptions;
// Process batch operation input (comma-separated IDs or array from input items)
function processBatchIds(explicitIds, inputItems, idField = 'id') {
if (explicitIds) {
return explicitIds;
}
if (!inputItems || inputItems.length === 0) {
throw new Error('No IDs provided or found in input items.');
}
const ids = inputItems
.map((item) => item.json?.[idField] ?? item.json?.id)
.filter((id) => id !== undefined && id !== null && id !== '')
.map((id) => String(id));
if (ids.length === 0) {
throw new Error(`No valid ${idField} values found in input items.`);
}
return ids.join(',');
}
exports.processBatchIds = processBatchIds;
// Create success response for batch operations
function createBatchSuccessResponse(operation, ids, customMessage) {
return {
success: true,
processedIds: ids,
count: ids.length,
message: customMessage || `Successfully ${operation} ${ids.length} items.`,
};
}
exports.createBatchSuccessResponse = createBatchSuccessResponse;
// Convert numeric strings to numbers recursively
function convertNumericStrings(data) {
if (data === null || data === undefined) {
return data;
}
if (typeof data === 'string') {
// Check if string is a valid number (including negative numbers and decimals)
const numericRegex = /^-?\d+(\.\d+)?$/;
if (numericRegex.test(data)) {
const num = parseFloat(data);
// Only convert if parseFloat doesn't lose precision and result is finite
if (!isNaN(num) && isFinite(num) && num.toString() === data) {
return num;
}
}
return data;
}
if (Array.isArray(data)) {
return data.map(convertNumericStrings);
}
if (typeof data === 'object') {
const converted = {};
for (const [key, value] of Object.entries(data)) {
converted[key] = convertNumericStrings(value);
}
return converted;
}
return data;
}
exports.convertNumericStrings = convertNumericStrings;