@panoptic-it-solutions/n8n-nodes-datto-rmm
Version:
n8n node for Datto RMM integration
336 lines • 20.3 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.executeJobOperation = executeJobOperation;
const n8n_workflow_1 = require("n8n-workflow");
const api_helper_1 = require("../../helpers/api.helper");
const errorHandler_1 = require("../../helpers/errorHandler");
async function executeJobOperation() {
const items = this.getInputData();
const operation = this.getNodeParameter('operation', 0);
const returnData = [];
return (0, errorHandler_1.handleErrors)(this, async () => {
for (let i = 0; i < items.length; i++) {
try {
let responseData;
switch (operation) {
case 'get':
{
const jobUid = this.getNodeParameter('jobUid', i);
responseData = await api_helper_1.dattoRmmApiRequest.call(this, 'GET', `/api/v2/job/${jobUid}`);
}
break;
case 'getComponents':
{
const jobUid = this.getNodeParameter('jobUid', i);
responseData = await api_helper_1.dattoRmmApiRequest.call(this, 'GET', `/api/v2/job/${jobUid}/components`);
}
break;
case 'getResults':
{
const jobUid = this.getNodeParameter('jobUid', i);
const deviceUid = this.getNodeParameter('deviceUid', i);
if (!(deviceUid === null || deviceUid === void 0 ? void 0 : deviceUid.trim())) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Device UID is required for getting job results', { itemIndex: i });
}
const endpoint = `/api/v2/job/${jobUid}/results/${deviceUid.trim()}`;
responseData = await api_helper_1.dattoRmmApiRequest.call(this, 'GET', endpoint);
}
break;
case 'getStdOut':
{
const jobUid = this.getNodeParameter('jobUid', i);
const deviceUid = this.getNodeParameter('deviceUid', i);
if (!(deviceUid === null || deviceUid === void 0 ? void 0 : deviceUid.trim())) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Device UID is required for getting job standard output', { itemIndex: i });
}
const endpoint = `/api/v2/job/${jobUid}/results/${deviceUid.trim()}/stdout`;
responseData = await api_helper_1.dattoRmmApiRequest.call(this, 'GET', endpoint);
}
break;
case 'getStdErr':
{
const jobUid = this.getNodeParameter('jobUid', i);
const deviceUid = this.getNodeParameter('deviceUid', i);
if (!(deviceUid === null || deviceUid === void 0 ? void 0 : deviceUid.trim())) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Device UID is required for getting job standard error', { itemIndex: i });
}
const endpoint = `/api/v2/job/${jobUid}/results/${deviceUid.trim()}/stderr`;
responseData = await api_helper_1.dattoRmmApiRequest.call(this, 'GET', endpoint);
}
break;
case 'getHistory':
{
const jobUid = this.getNodeParameter('jobUid', i);
const retrieveAll = this.getNodeParameter('retrieveAll', i, true);
const startDate = this.getNodeParameter('startDate', i, '');
const endDate = this.getNodeParameter('endDate', i, '');
const status = this.getNodeParameter('status', i, '');
const queryParams = {};
if (startDate === null || startDate === void 0 ? void 0 : startDate.trim()) {
queryParams.startDate = startDate.trim();
}
if (endDate === null || endDate === void 0 ? void 0 : endDate.trim()) {
queryParams.endDate = endDate.trim();
}
if (status === null || status === void 0 ? void 0 : status.trim()) {
queryParams.status = status.trim();
}
if (retrieveAll) {
const allHistory = await api_helper_1.dattoRmmApiRequestAllItems.call(this, 'GET', `/api/v2/job/${jobUid}/history`, {}, queryParams);
responseData = { history: allHistory };
}
else {
const page = this.getNodeParameter('page', i, 1);
const max = this.getNodeParameter('max', i, 100);
queryParams.page = page;
queryParams.max = max;
responseData = await api_helper_1.dattoRmmApiRequest.call(this, 'GET', `/api/v2/job/${jobUid}/history`, {}, queryParams);
}
}
break;
case 'runOnSite':
{
const siteUid = this.getNodeParameter('siteUid', i);
const componentUid = this.getNodeParameter('componentUid', i);
const jobName = this.getNodeParameter('jobName', i);
const deviceFilters = this.getNodeParameter('deviceFilters', i, {});
const executionOptions = this.getNodeParameter('executionOptions', i, {});
if (!(siteUid === null || siteUid === void 0 ? void 0 : siteUid.trim())) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Site UID is required for running jobs on site', { itemIndex: i });
}
if (!(componentUid === null || componentUid === void 0 ? void 0 : componentUid.trim())) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Component UID is required for running jobs on site', { itemIndex: i });
}
const batchSize = executionOptions.batchSize || 10;
const continueOnFail = executionOptions.continueOnFail !== false;
const includeSkipped = executionOptions.includeSkipped === true;
const operatingSystem = deviceFilters.operatingSystem || '';
const deviceType = deviceFilters.deviceType || '';
const onlineOnly = deviceFilters.onlineOnly !== false;
try {
const siteDevicesResponse = await api_helper_1.dattoRmmApiRequest.call(this, 'GET', `/api/v2/site/${siteUid}/devices`);
let devices = siteDevicesResponse.data || [];
if (operatingSystem) {
devices = devices.filter((device) => { var _a; return (_a = device.operatingSystem) === null || _a === void 0 ? void 0 : _a.toLowerCase().includes(operatingSystem.toLowerCase()); });
}
if (deviceType) {
devices = devices.filter((device) => device.deviceType === deviceType);
}
if (onlineOnly) {
devices = devices.filter((device) => device.status === 'online' || device.online === true);
}
const totalDevices = devices.length;
const results = [];
const errors = [];
const skipped = [];
if (totalDevices === 0) {
responseData = {
summary: {
totalDevices: 0,
processed: 0,
successful: 0,
failed: 0,
skipped: 0,
siteName: siteUid,
jobName: jobName,
componentUid: componentUid,
},
message: 'No devices found matching the specified criteria',
results: [],
errors: [],
skipped: includeSkipped ? [] : undefined,
};
break;
}
for (let batchStart = 0; batchStart < devices.length; batchStart += batchSize) {
const batchDevices = devices.slice(batchStart, batchStart + batchSize);
for (const device of batchDevices) {
try {
const jobBody = {
jobName: `${jobName} - ${device.hostname || device.displayName || device.uid}`,
jobComponent: {
componentUid,
variables: [],
},
};
const jobResult = await api_helper_1.dattoRmmApiRequest.call(this, 'PUT', `/api/v2/device/${device.uid}/quickjob`, jobBody);
results.push({
deviceUid: device.uid,
deviceName: device.hostname || device.displayName || device.uid,
deviceType: device.deviceType || 'Unknown',
operatingSystem: device.operatingSystem || 'Unknown',
status: 'success',
jobResponse: jobResult,
});
}
catch (error) {
const errorInfo = {
deviceUid: device.uid,
deviceName: device.hostname || device.displayName || device.uid,
deviceType: device.deviceType || 'Unknown',
operatingSystem: device.operatingSystem || 'Unknown',
status: 'error',
error: error.message || 'Unknown error occurred',
statusCode: error.statusCode || 0,
};
errors.push(errorInfo);
if (!continueOnFail) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Job execution failed on device ${device.hostname || device.uid}: ${error.message}`, { itemIndex: i });
}
}
}
if (batchStart + batchSize < devices.length) {
await new Promise((resolve) => setTimeout(resolve, 1000));
}
}
responseData = {
summary: {
totalDevices: totalDevices,
processed: results.length + errors.length,
successful: results.length,
failed: errors.length,
skipped: skipped.length,
siteName: siteUid,
jobName: jobName,
componentUid: componentUid,
filters: {
operatingSystem: operatingSystem || null,
deviceType: deviceType || null,
onlineOnly: onlineOnly,
},
},
results: results,
errors: errors.length > 0 ? errors : undefined,
skipped: includeSkipped && skipped.length > 0 ? skipped : undefined,
};
}
catch (error) {
if (error.statusCode === 404) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Site with UID "${siteUid}" was not found`, { itemIndex: i });
}
throw error;
}
}
break;
default:
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `The operation "${operation}" is not supported for job resource`, {
description: `Available operations: get, getComponents, getResults, getStdOut, getStdErr, getHistory, runOnSite`,
});
}
if (Array.isArray(responseData)) {
responseData.forEach((item) => {
returnData.push({
json: item,
pairedItem: { item: i },
});
});
}
else if (responseData && typeof responseData === 'object') {
let dataArray = [];
switch (operation) {
case 'getResults':
dataArray = responseData.results || [];
break;
case 'getHistory':
dataArray = responseData.history || [];
break;
case 'runOnSite':
returnData.push({
json: {
...responseData.summary,
operation: 'runOnSite',
type: 'summary',
},
pairedItem: { item: i },
});
if (responseData.results && responseData.results.length > 0) {
responseData.results.forEach((result) => {
returnData.push({
json: {
...result,
type: 'device_result',
operation: 'runOnSite',
},
pairedItem: { item: i },
});
});
}
if (responseData.errors && responseData.errors.length > 0) {
responseData.errors.forEach((error) => {
returnData.push({
json: {
...error,
type: 'device_error',
operation: 'runOnSite',
},
pairedItem: { item: i },
});
});
}
if (responseData.skipped && responseData.skipped.length > 0) {
responseData.skipped.forEach((skippedDevice) => {
returnData.push({
json: {
...skippedDevice,
type: 'device_skipped',
operation: 'runOnSite',
},
pairedItem: { item: i },
});
});
}
continue;
default:
if (responseData.data && Array.isArray(responseData.data)) {
dataArray = responseData.data;
}
else {
returnData.push({
json: responseData,
pairedItem: { item: i },
});
continue;
}
}
if (dataArray.length > 0) {
dataArray.forEach((item) => {
returnData.push({
json: item,
pairedItem: { item: i },
});
});
}
else {
returnData.push({
json: {
message: `No data found for ${operation}`,
pageDetails: responseData.pageDetails || null,
operation: operation,
},
pairedItem: { item: i },
});
}
}
}
catch (error) {
if (this.continueOnFail()) {
returnData.push({
json: {
error: error.message || 'Unknown error occurred',
itemIndex: i,
operation: operation,
resource: 'job',
},
pairedItem: {
item: i,
},
});
continue;
}
throw error;
}
}
return [returnData];
});
}
//# sourceMappingURL=execute.js.map