mirror of
https://github.com/n8n-io/n8n.git
synced 2024-09-21 15:27:32 -07:00
704 lines
20 KiB
TypeScript
704 lines
20 KiB
TypeScript
import {
|
||
IHookFunctions,
|
||
IWebhookFunctions,
|
||
} from 'n8n-core';
|
||
|
||
import {
|
||
IDataObject,
|
||
ILoadOptionsFunctions,
|
||
INodeExecutionData,
|
||
INodePropertyOptions,
|
||
INodeType,
|
||
INodeTypeDescription,
|
||
IWebhookResponseData,
|
||
} from 'n8n-workflow';
|
||
|
||
import {
|
||
idsExist,
|
||
surveyMonkeyApiRequest,
|
||
surveyMonkeyRequestAllItems,
|
||
} from './GenericFunctions';
|
||
|
||
import {
|
||
IAnswer,
|
||
IChoice,
|
||
IQuestion,
|
||
IRow,
|
||
IOther,
|
||
} from './Interfaces';
|
||
|
||
import {
|
||
createHmac,
|
||
} from 'crypto';
|
||
|
||
export class SurveyMonkeyTrigger implements INodeType {
|
||
description: INodeTypeDescription = {
|
||
displayName: 'SurveyMonkey Trigger',
|
||
name: 'surveyMonkeyTrigger',
|
||
icon: 'file:surveyMonkey.png',
|
||
group: ['trigger'],
|
||
version: 1,
|
||
description: 'Starts the workflow when Survey Monkey events occure.',
|
||
defaults: {
|
||
name: 'SurveyMonkey Trigger',
|
||
color: '#53b675',
|
||
},
|
||
inputs: [],
|
||
outputs: ['main'],
|
||
credentials: [
|
||
{
|
||
name: 'surveyMonkeyApi',
|
||
required: true,
|
||
},
|
||
],
|
||
webhooks: [
|
||
{
|
||
name: 'setup',
|
||
httpMethod: 'HEAD',
|
||
responseMode: 'onReceived',
|
||
path: 'webhook',
|
||
},
|
||
{
|
||
name: 'default',
|
||
httpMethod: 'POST',
|
||
responseMode: 'onReceived',
|
||
path: 'webhook',
|
||
},
|
||
],
|
||
properties: [
|
||
{
|
||
displayName: 'Type',
|
||
name: 'objectType',
|
||
type: 'options',
|
||
options: [
|
||
{
|
||
name: 'Collector',
|
||
value: 'collector',
|
||
},
|
||
{
|
||
name: 'Survey',
|
||
value: 'survey',
|
||
},
|
||
],
|
||
default: '',
|
||
required: true,
|
||
},
|
||
{
|
||
displayName: 'Event',
|
||
name: 'event',
|
||
displayOptions: {
|
||
show: {
|
||
objectType: [
|
||
'survey'
|
||
],
|
||
},
|
||
},
|
||
type: 'options',
|
||
options: [
|
||
{
|
||
name: 'Collector Created',
|
||
value: 'collector_created',
|
||
description: 'A collector is created',
|
||
},
|
||
{
|
||
name: 'Collector Updated',
|
||
value: 'collector_updated',
|
||
description: 'A collector is updated',
|
||
},
|
||
{
|
||
name: 'Collector Deleted',
|
||
value: 'collector_deleted',
|
||
description: 'A collector is deleted',
|
||
},
|
||
{
|
||
name: 'Response Completed',
|
||
value: 'response_completed',
|
||
description: 'A survey response is completed',
|
||
},
|
||
{
|
||
name: 'Response Created',
|
||
value: 'response_created',
|
||
description: 'A respondent begins a survey',
|
||
},
|
||
{
|
||
name: 'Response Deleted',
|
||
value: 'response_deleted',
|
||
description: 'A response is deleted',
|
||
},
|
||
{
|
||
name: 'Response Disqualified',
|
||
value: 'response_disqualified',
|
||
description: 'A survey response is disqualified ',
|
||
},
|
||
{
|
||
name: 'Response Overquota',
|
||
value: 'response_overquota',
|
||
description: `A response is over a survey’s quota`,
|
||
},
|
||
{
|
||
name: 'Response Updated',
|
||
value: 'response_updated',
|
||
description: 'A survey response is updated',
|
||
},
|
||
{
|
||
name: 'Survey Created',
|
||
value: 'survey_created',
|
||
description: 'A survey is created',
|
||
},
|
||
{
|
||
name: 'Survey Deleted',
|
||
value: 'survey_deleted',
|
||
description: 'A survey is deleted',
|
||
},
|
||
{
|
||
name: 'Survey Updated',
|
||
value: 'survey_updated',
|
||
description: 'A survey is updated',
|
||
},
|
||
],
|
||
default: '',
|
||
required: true,
|
||
},
|
||
{
|
||
displayName: 'Event',
|
||
name: 'event',
|
||
type: 'options',
|
||
displayOptions: {
|
||
show: {
|
||
objectType: [
|
||
'collector',
|
||
],
|
||
},
|
||
},
|
||
options: [
|
||
{
|
||
name: 'Collector Updated',
|
||
value: 'collector_updated',
|
||
description: 'A collector is updated',
|
||
},
|
||
{
|
||
name: 'Collector Deleted',
|
||
value: 'collector_deleted',
|
||
description: 'A collector is deleted',
|
||
},
|
||
{
|
||
name: 'Response Completed',
|
||
value: 'response_completed',
|
||
description: 'A survey response is completed',
|
||
},
|
||
{
|
||
name: 'Response Created',
|
||
value: 'response_created',
|
||
description: 'A respondent begins a survey',
|
||
},
|
||
{
|
||
name: 'Response Deleted',
|
||
value: 'response_deleted',
|
||
description: 'A response is deleted',
|
||
},
|
||
{
|
||
name: 'Response Disqualified',
|
||
value: 'response_disqualified',
|
||
description: 'A survey response is disqualified ',
|
||
},
|
||
{
|
||
name: 'Response Overquota',
|
||
value: 'response_overquota',
|
||
description: `A response is over a survey’s quota`,
|
||
},
|
||
{
|
||
name: 'Response Updated',
|
||
value: 'response_updated',
|
||
description: 'A survey response is updated',
|
||
},
|
||
],
|
||
default: '',
|
||
required: true,
|
||
},
|
||
{
|
||
displayName: 'Survey IDs',
|
||
name: 'surveyIds',
|
||
type: 'multiOptions',
|
||
displayOptions: {
|
||
show: {
|
||
objectType: [
|
||
'survey',
|
||
],
|
||
},
|
||
hide: {
|
||
event: [
|
||
'survey_created',
|
||
],
|
||
},
|
||
},
|
||
typeOptions: {
|
||
loadOptionsMethod: 'getSurveys',
|
||
},
|
||
options: [],
|
||
default: [],
|
||
required: true,
|
||
},
|
||
{
|
||
displayName: 'Survey ID',
|
||
name: 'surveyId',
|
||
type: 'options',
|
||
displayOptions: {
|
||
show: {
|
||
objectType: [
|
||
'collector',
|
||
],
|
||
},
|
||
},
|
||
typeOptions: {
|
||
loadOptionsMethod: 'getSurveys',
|
||
},
|
||
default: [],
|
||
required: true,
|
||
},
|
||
{
|
||
displayName: 'Collector IDs',
|
||
name: 'collectorIds',
|
||
type: 'multiOptions',
|
||
displayOptions: {
|
||
show: {
|
||
objectType: [
|
||
'collector',
|
||
],
|
||
},
|
||
},
|
||
typeOptions: {
|
||
loadOptionsMethod: 'getCollectors',
|
||
loadOptionsDependsOn: [
|
||
'surveyId',
|
||
],
|
||
},
|
||
options: [],
|
||
default: [],
|
||
required: true,
|
||
},
|
||
{
|
||
displayName: 'Resolve Data',
|
||
name: 'resolveData',
|
||
type: 'boolean',
|
||
displayOptions: {
|
||
show: {
|
||
event: [
|
||
'response_completed',
|
||
],
|
||
},
|
||
},
|
||
default: true,
|
||
description: 'By default the webhook-data only contain the IDs. If this option gets activated it<br />will resolve the data automatically.',
|
||
},
|
||
{
|
||
displayName: 'Only Answers',
|
||
name: 'onlyAnswers',
|
||
displayOptions: {
|
||
show: {
|
||
resolveData: [
|
||
true,
|
||
],
|
||
event: [
|
||
'response_completed',
|
||
],
|
||
},
|
||
},
|
||
type: 'boolean',
|
||
default: true,
|
||
description: 'Returns only the answers of the form and not any of the other data.',
|
||
},
|
||
],
|
||
};
|
||
|
||
methods = {
|
||
loadOptions: {
|
||
// Get all the survey's collectors to display them to user so that he can
|
||
// select them easily
|
||
async getCollectors(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
|
||
const surveyId = this.getCurrentNodeParameter('surveyId');
|
||
const returnData: INodePropertyOptions[] = [];
|
||
const collectors = await surveyMonkeyRequestAllItems.call(this, 'data', 'GET', `/surveys/${surveyId}/collectors`);
|
||
for (const collector of collectors) {
|
||
const collectorName = collector.name;
|
||
const collectorId = collector.id;
|
||
returnData.push({
|
||
name: collectorName,
|
||
value: collectorId,
|
||
});
|
||
}
|
||
return returnData;
|
||
},
|
||
|
||
// Get all the surveys to display them to user so that he can
|
||
// select them easily
|
||
async getSurveys(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
|
||
const returnData: INodePropertyOptions[] = [];
|
||
const surveys = await surveyMonkeyRequestAllItems.call(this, 'data', 'GET', '/surveys');
|
||
for (const survey of surveys) {
|
||
const surveyName = survey.title;
|
||
const surveyId = survey.id;
|
||
returnData.push({
|
||
name: surveyName,
|
||
value: surveyId,
|
||
});
|
||
}
|
||
return returnData;
|
||
},
|
||
},
|
||
};
|
||
|
||
// @ts-ignore (because of request)
|
||
webhookMethods = {
|
||
default: {
|
||
async checkExists(this: IHookFunctions): Promise<boolean> {
|
||
const objectType = this.getNodeParameter('objectType') as string;
|
||
const event = this.getNodeParameter('event') as string;
|
||
// Check all the webhooks which exist already if it is identical to the
|
||
// one that is supposed to get created.
|
||
const endpoint = '/webhooks';
|
||
|
||
const responseData = await surveyMonkeyRequestAllItems.call(this, 'data', 'GET', endpoint, {});
|
||
|
||
const webhookUrl = this.getNodeWebhookUrl('default');
|
||
|
||
const ids: string[] = [];
|
||
|
||
if (objectType === 'survey' && event !== 'survey_created') {
|
||
const surveyIds = this.getNodeParameter('surveyIds') as string[];
|
||
ids.push.apply(ids, surveyIds);
|
||
} else if (objectType === 'collector') {
|
||
const collectorIds = this.getNodeParameter('collectorIds') as string[];
|
||
ids.push.apply(ids, collectorIds);
|
||
}
|
||
|
||
for (const webhook of responseData) {
|
||
const webhookDetails = await surveyMonkeyApiRequest.call(this, 'GET', `/webhooks/${webhook.id}`);
|
||
if (webhookDetails.subscription_url === webhookUrl
|
||
&& idsExist(webhookDetails.object_ids as string[], ids as string[])
|
||
&& webhookDetails.event_type === event) {
|
||
// Set webhook-id to be sure that it can be deleted
|
||
const webhookData = this.getWorkflowStaticData('node');
|
||
webhookData.webhookId = webhook.id as string;
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
},
|
||
|
||
async create(this: IHookFunctions): Promise<boolean> {
|
||
const webhookUrl = this.getNodeWebhookUrl('default');
|
||
const event = this.getNodeParameter('event') as string;
|
||
const objectType = this.getNodeParameter('objectType') as string;
|
||
const endpoint = '/webhooks';
|
||
const ids: string[] = [];
|
||
|
||
if (objectType === 'survey' && event !== 'survey_created') {
|
||
const surveyIds = this.getNodeParameter('surveyIds') as string[];
|
||
ids.push.apply(ids, surveyIds);
|
||
} else if (objectType === 'collector') {
|
||
const collectorIds = this.getNodeParameter('collectorIds') as string[];
|
||
ids.push.apply(ids, collectorIds);
|
||
}
|
||
|
||
const body: IDataObject = {
|
||
name: `n8n - Webhook [${event}]`,
|
||
object_type: objectType,
|
||
object_ids: ids,
|
||
subscription_url: webhookUrl,
|
||
event_type: event,
|
||
};
|
||
|
||
if (objectType === 'survey' && event === 'survey_created') {
|
||
delete body.object_type;
|
||
delete body.object_ids;
|
||
}
|
||
|
||
let responseData: IDataObject = {};
|
||
|
||
responseData = await surveyMonkeyApiRequest.call(this, 'POST', endpoint, body);
|
||
|
||
if (responseData.id === undefined) {
|
||
// Required data is missing so was not successful
|
||
return false;
|
||
}
|
||
|
||
const webhookData = this.getWorkflowStaticData('node');
|
||
webhookData.webhookId = responseData.id as string;
|
||
|
||
return true;
|
||
},
|
||
async delete(this: IHookFunctions): Promise<boolean> {
|
||
const webhookData = this.getWorkflowStaticData('node');
|
||
if (webhookData.webhookId !== undefined) {
|
||
|
||
const endpoint = `/webhooks/${webhookData.webhookId}`;
|
||
|
||
try {
|
||
await surveyMonkeyApiRequest.call(this, 'DELETE', endpoint);
|
||
} catch (e) {
|
||
return false;
|
||
}
|
||
|
||
// Remove from the static workflow data so that it is clear
|
||
// that no webhooks are registred anymore
|
||
delete webhookData.webhookId;
|
||
}
|
||
|
||
return true;
|
||
},
|
||
},
|
||
};
|
||
|
||
async webhook(this: IWebhookFunctions): Promise<IWebhookResponseData> {
|
||
const event = this.getNodeParameter('event') as string;
|
||
const objectType = this.getNodeParameter('objectType') as string;
|
||
const credentials = this.getCredentials('surveyMonkeyApi') as IDataObject;
|
||
const headerData = this.getHeaderData() as IDataObject;
|
||
const req = this.getRequestObject();
|
||
const webhookName = this.getWebhookName();
|
||
|
||
if (webhookName === 'setup') {
|
||
// It is a create webhook confirmation request
|
||
return {};
|
||
}
|
||
|
||
if (headerData['sm-signature'] === undefined) {
|
||
return {};
|
||
}
|
||
|
||
return new Promise((resolve, reject) => {
|
||
const data: Buffer[] = [];
|
||
|
||
req.on('data', (chunk) => {
|
||
data.push(chunk);
|
||
});
|
||
|
||
req.on('end', async () => {
|
||
const computedSignature = createHmac('sha1', `${credentials.clientId}&${credentials.clientSecret}`).update(data.join('')).digest('base64');
|
||
if (headerData['sm-signature'] !== computedSignature) {
|
||
// Signature is not valid so ignore call
|
||
return {};
|
||
}
|
||
|
||
let responseData = JSON.parse(data.join(''));
|
||
let endpoint = '';
|
||
|
||
let returnItem: INodeExecutionData[] = [
|
||
{
|
||
json: responseData,
|
||
}
|
||
];
|
||
|
||
if (event === 'response_completed') {
|
||
const resolveData = this.getNodeParameter('resolveData') as boolean;
|
||
if (resolveData) {
|
||
if (objectType === 'survey') {
|
||
endpoint = `/surveys/${responseData.resources.survey_id}/responses/${responseData.object_id}/details`;
|
||
} else {
|
||
endpoint = `/collectors/${responseData.resources.collector_id}/responses/${responseData.object_id}/details`;
|
||
}
|
||
responseData = await surveyMonkeyApiRequest.call(this, 'GET', endpoint);
|
||
const surveyId = responseData.survey_id;
|
||
|
||
const questions: IQuestion[] = [];
|
||
const answers = new Map<string, IAnswer[]>();
|
||
|
||
const { pages } = await surveyMonkeyApiRequest.call(this, 'GET', `/surveys/${surveyId}/details`);
|
||
|
||
for (const page of pages) {
|
||
questions.push.apply(questions, page.questions);
|
||
}
|
||
|
||
for (const page of responseData.pages as IDataObject[]) {
|
||
for (const question of page.questions as IDataObject[]) {
|
||
answers.set(question.id as string, question.answers as IAnswer[]);
|
||
}
|
||
}
|
||
|
||
const responseQuestions = new Map<string, number | string | string[] | IDataObject>();
|
||
|
||
for (const question of questions) {
|
||
|
||
/*
|
||
TODO: add support for premium components
|
||
- File Upload
|
||
- Matrix of dropdowm menus
|
||
*/
|
||
|
||
// if question does not have an answer ignore it
|
||
if (!answers.get(question.id)) {
|
||
continue;
|
||
}
|
||
|
||
const heading = question.headings![0].heading as string;
|
||
|
||
if (question.family === 'open_ended' || question.family === 'datetime') {
|
||
if (question.subtype !== 'multi') {
|
||
responseQuestions.set(heading, answers.get(question.id)![0].text as string);
|
||
} else {
|
||
|
||
const results: IDataObject = {};
|
||
const keys = (question.answers.rows as IRow[]).map(e => e.text) as string[];
|
||
const values = answers.get(question.id)?.map(e => e.text) as string[];
|
||
for (let i = 0; i < keys.length; i++) {
|
||
// if for some reason there are questions texts repeted add the index to the key
|
||
if (results[keys[i]] !== undefined) {
|
||
results[`${keys[i]}(${i})`] = values[i] || '';
|
||
} else {
|
||
results[keys[i]] = values[i] || '';
|
||
}
|
||
}
|
||
responseQuestions.set(heading, results);
|
||
}
|
||
}
|
||
|
||
if (question.family === 'single_choice') {
|
||
const other = question.answers.other as IOther;
|
||
if (other && other.visible && other.is_answer_choice && answers.get(question.id)![0].other_id) {
|
||
responseQuestions.set(heading, answers.get(question.id)![0].text as string);
|
||
|
||
} else if (other && other.visible && !other.is_answer_choice){
|
||
const choiceId = answers.get(question.id)![0].choice_id;
|
||
|
||
const choice = (question.answers.choices as IChoice[])
|
||
.filter(e => e.id === choiceId)[0];
|
||
|
||
const comment = answers.get(question.id)
|
||
?.find(e => e.other_id === other.id)?.text as string;
|
||
responseQuestions.set(heading, { value: choice.text, comment });
|
||
|
||
} else {
|
||
const choiceId = answers.get(question.id)![0].choice_id;
|
||
const choice = (question.answers.choices as IChoice[])
|
||
.filter(e => e.id === choiceId)[0];
|
||
responseQuestions.set(heading, choice.text);
|
||
}
|
||
}
|
||
|
||
if (question.family === 'multiple_choice') {
|
||
const other = question.answers.other as IOther;
|
||
const choiceIds = answers.get(question.id)?.map((e) => e.choice_id);
|
||
const value = (question.answers.choices as IChoice[])
|
||
.filter(e => choiceIds?.includes(e.id))
|
||
.map(e => e.text) as string[];
|
||
// if "Add an "Other" Answer Option for Comments" is active and was selected
|
||
if (other && other.is_answer_choice && other.visible) {
|
||
const text = answers.get(question.id)
|
||
?.find(e => e.other_id === other.id)?.text as string;
|
||
value.push(text);
|
||
}
|
||
responseQuestions.set(heading, value);
|
||
}
|
||
|
||
if (question.family === 'matrix') {
|
||
// if more than one row it's a matrix/rating-scale
|
||
const rows = question.answers.rows as IRow[];
|
||
|
||
if (rows.length > 1) {
|
||
|
||
const results: IDataObject = {};
|
||
const choiceIds = answers.get(question.id)?.map(e => e.choice_id) as string[];
|
||
const rowIds = answers.get(question.id)?.map(e => e.row_id) as string[];
|
||
|
||
const rowsValues = (question.answers.rows as IRow[])
|
||
.filter(e => rowIds!.includes(e.id as string))
|
||
.map(e => e.text);
|
||
|
||
const choicesValues = (question.answers.choices as IChoice[])
|
||
.filter(e => choiceIds!.includes(e.id as string))
|
||
.map(e => e.text);
|
||
|
||
for (let i = 0; i < rowsValues.length; i++) {
|
||
results[rowsValues[i]] = choicesValues[i] || '';
|
||
}
|
||
|
||
// add the rows that were not answered
|
||
for (const row of question.answers.rows as IDataObject[]) {
|
||
if (!rowIds.includes(row.id as string)) {
|
||
results[row.text as string] = '';
|
||
}
|
||
}
|
||
// the comment then add the comment
|
||
const other = question.answers.other as IOther;
|
||
if (other !== undefined && other.visible) {
|
||
results.comment = answers.get(question.id)?.filter((e) => e.other_id)[0].text;
|
||
}
|
||
|
||
responseQuestions.set(heading, results);
|
||
|
||
} else {
|
||
const choiceIds = answers.get(question.id)?.map((e) => e.choice_id);
|
||
const value = (question.answers.choices as IChoice[])
|
||
.filter(e => choiceIds!.includes(e.id as string))
|
||
.map(e => (e.text === '') ? e.weight : e.text)[0];
|
||
responseQuestions.set(heading, value);
|
||
|
||
// if "Add an Other Answer Option for Comments" is active then add comment to the answer
|
||
const other = question.answers.other as IOther;
|
||
if (other !== undefined && other.visible) {
|
||
const response: IDataObject = {};
|
||
//const questionName = (question.answers.other as IOther).text as string;
|
||
const text = answers.get(question.id)?.filter((e) => e.other_id)[0].text;
|
||
response.value = value;
|
||
response.comment = text;
|
||
responseQuestions.set(heading, response);
|
||
}
|
||
}
|
||
}
|
||
|
||
if (question.family === 'demographic') {
|
||
const rows: IDataObject = {};
|
||
for (const row of answers.get(question.id) as IAnswer[]) {
|
||
rows[row.row_id as string] = row.text;
|
||
}
|
||
const addressInfo: IDataObject = {};
|
||
for (const answer of question.answers.rows as IDataObject[]) {
|
||
addressInfo[answer.type as string] = rows[answer.id as string] || '';
|
||
}
|
||
responseQuestions.set(heading, addressInfo);
|
||
}
|
||
|
||
if (question.family === 'presentation') {
|
||
if (question.subtype === 'image') {
|
||
const { url } = question.headings![0].image as IDataObject;
|
||
responseQuestions.set(heading, url as string);
|
||
}
|
||
}
|
||
}
|
||
delete responseData.pages;
|
||
responseData.questions = {};
|
||
|
||
// Map the "Map" to JSON
|
||
const tuples = JSON.parse(JSON.stringify([...responseQuestions]));
|
||
for (const [key, value] of tuples) {
|
||
responseData.questions[key] = value;
|
||
}
|
||
|
||
const onlyAnswers = this.getNodeParameter('onlyAnswers') as boolean;
|
||
if (onlyAnswers) {
|
||
responseData = responseData.questions;
|
||
}
|
||
|
||
returnItem = [
|
||
{
|
||
json: responseData,
|
||
}
|
||
];
|
||
}
|
||
}
|
||
|
||
return resolve({
|
||
workflowData: [
|
||
returnItem,
|
||
],
|
||
});
|
||
});
|
||
|
||
req.on('error', (err) => {
|
||
throw new Error(err.message);
|
||
});
|
||
});
|
||
}
|
||
}
|