mirror of
https://github.com/n8n-io/n8n.git
synced 2024-12-29 06:29:42 -08:00
255 lines
6.6 KiB
TypeScript
255 lines
6.6 KiB
TypeScript
import type {
|
|
IHookFunctions,
|
|
IWebhookFunctions,
|
|
IDataObject,
|
|
INodeType,
|
|
INodeTypeDescription,
|
|
IWebhookResponseData,
|
|
} from 'n8n-workflow';
|
|
|
|
import { calendlyApiRequest, getAuthenticationType } from './GenericFunctions';
|
|
|
|
export class CalendlyTrigger implements INodeType {
|
|
description: INodeTypeDescription = {
|
|
displayName: 'Calendly Trigger',
|
|
name: 'calendlyTrigger',
|
|
icon: 'file:calendly.svg',
|
|
group: ['trigger'],
|
|
version: 1,
|
|
description: 'Starts the workflow when Calendly events occur',
|
|
defaults: {
|
|
name: 'Calendly Trigger',
|
|
},
|
|
inputs: [],
|
|
outputs: ['main'],
|
|
credentials: [
|
|
{
|
|
name: 'calendlyApi',
|
|
required: true,
|
|
},
|
|
],
|
|
webhooks: [
|
|
{
|
|
name: 'default',
|
|
httpMethod: 'POST',
|
|
responseMode: 'onReceived',
|
|
path: 'webhook',
|
|
},
|
|
],
|
|
properties: [
|
|
{
|
|
displayName: 'Scope',
|
|
name: 'scope',
|
|
type: 'options',
|
|
default: 'user',
|
|
required: true,
|
|
hint: 'Ignored if you are using an API Key',
|
|
options: [
|
|
{
|
|
name: 'Organization',
|
|
value: 'organization',
|
|
description: 'Triggers the webhook for all subscribed events within the organization',
|
|
},
|
|
{
|
|
name: 'User',
|
|
value: 'user',
|
|
description:
|
|
'Triggers the webhook for subscribed events that belong to the current user',
|
|
},
|
|
],
|
|
},
|
|
{
|
|
displayName: 'Events',
|
|
name: 'events',
|
|
type: 'multiOptions',
|
|
options: [
|
|
{
|
|
name: 'invitee.created',
|
|
value: 'invitee.created',
|
|
description: 'Receive notifications when a new Calendly event is created',
|
|
},
|
|
{
|
|
name: 'invitee.canceled',
|
|
value: 'invitee.canceled',
|
|
description: 'Receive notifications when a Calendly event is canceled',
|
|
},
|
|
],
|
|
default: [],
|
|
required: true,
|
|
},
|
|
],
|
|
};
|
|
|
|
webhookMethods = {
|
|
default: {
|
|
async checkExists(this: IHookFunctions): Promise<boolean> {
|
|
const webhookUrl = this.getNodeWebhookUrl('default');
|
|
const webhookData = this.getWorkflowStaticData('node');
|
|
const events = this.getNodeParameter('events') as string;
|
|
const { apiKey } = (await this.getCredentials('calendlyApi')) as { apiKey: string };
|
|
|
|
const authenticationType = getAuthenticationType(apiKey);
|
|
|
|
// remove condition once API Keys are deprecated
|
|
if (authenticationType === 'apiKey') {
|
|
const endpoint = '/hooks';
|
|
const { data } = await calendlyApiRequest.call(this, 'GET', endpoint, {});
|
|
|
|
for (const webhook of data) {
|
|
if (webhook.attributes.url === webhookUrl) {
|
|
for (const event of events) {
|
|
if (!webhook.attributes.events.includes(event)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
// Set webhook-id to be sure that it can be deleted
|
|
webhookData.webhookId = webhook.id as string;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
if (authenticationType === 'accessToken') {
|
|
const scope = this.getNodeParameter('scope', 0) as string;
|
|
const { resource } = await calendlyApiRequest.call(this, 'GET', '/users/me');
|
|
|
|
const qs: IDataObject = {};
|
|
|
|
if (scope === 'user') {
|
|
qs.scope = 'user';
|
|
qs.organization = resource.current_organization;
|
|
qs.user = resource.uri;
|
|
}
|
|
|
|
if (scope === 'organization') {
|
|
qs.scope = 'organization';
|
|
qs.organization = resource.current_organization;
|
|
}
|
|
|
|
const endpoint = '/webhook_subscriptions';
|
|
const { collection } = await calendlyApiRequest.call(this, 'GET', endpoint, {}, qs);
|
|
|
|
for (const webhook of collection) {
|
|
if (webhook.callback_url === webhookUrl) {
|
|
for (const event of events) {
|
|
if (!webhook.events.includes(event)) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
webhookData.webhookURI = webhook.uri;
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
},
|
|
async create(this: IHookFunctions): Promise<boolean> {
|
|
const webhookData = this.getWorkflowStaticData('node');
|
|
const webhookUrl = this.getNodeWebhookUrl('default');
|
|
const events = this.getNodeParameter('events') as string;
|
|
const { apiKey } = (await this.getCredentials('calendlyApi')) as { apiKey: string };
|
|
|
|
const authenticationType = getAuthenticationType(apiKey);
|
|
|
|
// remove condition once API Keys are deprecated
|
|
if (authenticationType === 'apiKey') {
|
|
const endpoint = '/hooks';
|
|
|
|
const body = {
|
|
url: webhookUrl,
|
|
events,
|
|
};
|
|
|
|
const responseData = await calendlyApiRequest.call(this, 'POST', endpoint, body);
|
|
|
|
if (responseData.id === undefined) {
|
|
// Required data is missing so was not successful
|
|
return false;
|
|
}
|
|
|
|
webhookData.webhookId = responseData.id as string;
|
|
}
|
|
|
|
if (authenticationType === 'accessToken') {
|
|
const scope = this.getNodeParameter('scope', 0) as string;
|
|
const { resource } = await calendlyApiRequest.call(this, 'GET', '/users/me');
|
|
|
|
const body: IDataObject = {
|
|
url: webhookUrl,
|
|
events,
|
|
organization: resource.current_organization,
|
|
scope,
|
|
};
|
|
|
|
if (scope === 'user') {
|
|
body.user = resource.uri;
|
|
}
|
|
|
|
const endpoint = '/webhook_subscriptions';
|
|
const responseData = await calendlyApiRequest.call(this, 'POST', endpoint, body);
|
|
|
|
if (responseData?.resource === undefined || responseData?.resource?.uri === undefined) {
|
|
return false;
|
|
}
|
|
|
|
webhookData.webhookURI = responseData.resource.uri;
|
|
}
|
|
|
|
return true;
|
|
},
|
|
async delete(this: IHookFunctions): Promise<boolean> {
|
|
const webhookData = this.getWorkflowStaticData('node');
|
|
const { apiKey } = (await this.getCredentials('calendlyApi')) as { apiKey: string };
|
|
const authenticationType = getAuthenticationType(apiKey);
|
|
|
|
// remove condition once API Keys are deprecated
|
|
if (authenticationType === 'apiKey') {
|
|
if (webhookData.webhookId !== undefined) {
|
|
const endpoint = `/hooks/${webhookData.webhookId}`;
|
|
|
|
try {
|
|
await calendlyApiRequest.call(this, 'DELETE', endpoint);
|
|
} catch (error) {
|
|
return false;
|
|
}
|
|
|
|
// Remove from the static workflow data so that it is clear
|
|
// that no webhooks are registered anymore
|
|
delete webhookData.webhookId;
|
|
}
|
|
}
|
|
|
|
if (authenticationType === 'accessToken') {
|
|
if (webhookData.webhookURI !== undefined) {
|
|
try {
|
|
await calendlyApiRequest.call(
|
|
this,
|
|
'DELETE',
|
|
'',
|
|
{},
|
|
{},
|
|
webhookData.webhookURI as string,
|
|
);
|
|
} catch (error) {
|
|
return false;
|
|
}
|
|
|
|
delete webhookData.webhookURI;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
},
|
|
},
|
|
};
|
|
|
|
async webhook(this: IWebhookFunctions): Promise<IWebhookResponseData> {
|
|
const bodyData = this.getBodyData();
|
|
return {
|
|
workflowData: [this.helpers.returnJsonArray(bodyData)],
|
|
};
|
|
}
|
|
}
|