n8n-nodes-base
Version:
Base nodes of n8n
176 lines • 7.87 kB
JavaScript
;
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.BINARY_MIME_TYPE = void 0;
exports.getRevisionFile = getRevisionFile;
exports.sheetBinaryToArrayOfArrays = sheetBinaryToArrayOfArrays;
exports.arrayOfArraysToJson = arrayOfArraysToJson;
exports.compareRevisions = compareRevisions;
const isEqual_1 = __importDefault(require("lodash/isEqual"));
const zip_1 = __importDefault(require("lodash/zip"));
const XLSX = __importStar(require("xlsx"));
const transport_1 = require("./v2/transport");
exports.BINARY_MIME_TYPE = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
async function getRevisionFile(exportLink) {
const mimeType = exports.BINARY_MIME_TYPE;
const response = await transport_1.apiRequest.call(this, 'GET', '', undefined, { mimeType }, exportLink, undefined, {
resolveWithFullResponse: true,
encoding: null,
json: false,
});
return Buffer.from(response.body);
}
function sheetBinaryToArrayOfArrays(data, sheetName, range) {
const workbook = XLSX.read(data, { type: 'buffer', sheets: [sheetName] });
const sheet = workbook.Sheets[sheetName];
const sheetData = sheet['!ref']
? XLSX.utils.sheet_to_json(sheet, { header: 1, defval: '', range })
: [];
const lastDataRowIndex = sheetData.reduce((lastRowIndex, row, rowIndex) => {
if (row.some((cell) => cell !== '')) {
return rowIndex;
}
return lastRowIndex;
}, 0);
return sheetData.slice(0, lastDataRowIndex + 1);
}
function arrayOfArraysToJson(sheetData, columns) {
const returnData = [];
for (let rowIndex = 0; rowIndex < sheetData.length; rowIndex++) {
const rowData = {};
for (let columnIndex = 0; columnIndex < columns.length; columnIndex++) {
const columnName = columns[columnIndex];
const cellValue = sheetData[rowIndex][columnIndex] || '';
rowData[columnName] = cellValue;
}
returnData.push(rowData);
}
return returnData;
}
const getSpecificColumns = (row, selectedColumns, columns) => {
return row ? selectedColumns.map((column) => row[columns.indexOf(column) - 1]) : [];
};
const extractVersionData = (data, version, triggerEvent) => {
if (triggerEvent === 'anyUpdate') {
return data.map(({ [version]: entry, rowIndex, changeType }) => entry ? [rowIndex, changeType, ...entry] : [rowIndex, changeType]);
}
return data.map(({ [version]: entry, rowIndex }) => (entry ? [rowIndex, ...entry] : [rowIndex]));
};
function compareRevisions(previous, current, keyRow, includeInOutput, columnsToWatch, dataStartIndex, event) {
const dataLength = current.length > previous.length ? current.length : previous.length;
const columnsRowIndex = keyRow - 1;
const columnsInCurrent = current[columnsRowIndex];
const columnsInPrevious = previous[columnsRowIndex];
let columns = event === 'anyUpdate' ? ['row_number', 'change_type'] : ['row_number'];
if (columnsInCurrent !== undefined && columnsInPrevious !== undefined) {
columns =
columnsInCurrent.length > columnsInPrevious.length
? columns.concat(columnsInCurrent)
: columns.concat(columnsInPrevious);
}
else if (columnsInCurrent !== undefined) {
columns = columns.concat(columnsInCurrent);
}
else if (columnsInPrevious !== undefined) {
columns = columns.concat(columnsInPrevious);
}
const diffData = [];
for (let i = dataStartIndex; i < dataLength; i++) {
if (i === columnsRowIndex) {
continue;
}
// sheets API omits trailing empty columns, xlsx does not - so we need to pad the shorter array
if (Array.isArray(current[i]) && Array.isArray(previous[i])) {
while (current[i].length < previous[i].length) {
current[i].push('');
}
}
// if columnsToWatch is defined, only compare those columns
if (columnsToWatch?.length) {
const currentRow = getSpecificColumns(current[i], columnsToWatch, columns);
const previousRow = getSpecificColumns(previous[i], columnsToWatch, columns);
if ((0, isEqual_1.default)(currentRow, previousRow))
continue;
}
else {
if ((0, isEqual_1.default)(current[i], previous[i]))
continue;
}
if (event === 'rowUpdate' && (!previous[i] || previous[i].every((cell) => cell === '')))
continue;
let changeType = 'updated';
if (previous[i] === undefined) {
previous[i] = current[i].map(() => '');
changeType = 'added';
}
if (current[i] === undefined)
continue;
diffData.push({
rowIndex: i + 1,
previous: previous[i],
current: current[i],
changeType,
});
}
if (includeInOutput === 'old') {
return arrayOfArraysToJson(extractVersionData(diffData, 'previous', event), columns);
}
if (includeInOutput === 'both') {
const previousData = arrayOfArraysToJson(extractVersionData(diffData, 'previous', event), columns).map((row) => ({ previous: row }));
const currentData = arrayOfArraysToJson(extractVersionData(diffData, 'current', event), columns).map((row) => ({ current: row }));
const differences = currentData.map(({ current: currentRow }, index) => {
const { row_number, ...rest } = currentRow;
const returnData = {};
returnData.row_number = row_number;
Object.keys(rest).forEach((key) => {
const previousValue = previousData[index].previous[key];
const currentValue = currentRow[key];
if ((0, isEqual_1.default)(previousValue, currentValue))
return;
returnData[key] = {
previous: previousValue,
current: currentValue,
};
});
return { differences: returnData };
});
return (0, zip_1.default)(previousData, currentData, differences).map((row) => Object.assign({}, ...row));
}
return arrayOfArraysToJson(extractVersionData(diffData, 'current', event), columns);
}
//# sourceMappingURL=GoogleSheetsTrigger.utils.js.map