GoToWebinar node (#1422)

* Create scaffolding for node

* Add SVG logo

* Create scaffolding for generic functions

* Add index for descriptions

* Simplify retrieval of details

* Introduce minor fixes in generic functions

* Add attendee description

* Fix attendee description operation

* Add coorganizer description

* Add panelist description

* Add registrant description

* Add session description

* Add webinar description

* Register node and credentials

* Add scaffolding for credentials

* Minor creds fixes

* Fix SVG icon size and position

* Fix capitalization in description

* Fix credentials connection

* Add attendee fields

* Populate webinar description

* Remove organizer key from params

* Add timezones array constant

* Implement webinar:create

* Implement webinar:delete

* Convert times to fixed collection

* Add missing segments to endpoints

* Fix webinar:update operation

* Implement all-items request

* Add params for session:getAll

* Add params for webinar:getAll

* Implement session:getAll and webinar:getAll

* Implement session:get and session:getDetails

* Implement coorganizer:create

* Implement coorganizer:delete

* Implement coorganizer:getAll

* Implement coorganizer:delete

* Refactor time range for getAll operations

* Implement coorganizer:reinvite

* Implement panelist:create and panelist:getAll

* Implement panelist:delete and panelist:reinvite

* Remove array body helper types

* Implement registrant:create and registrant:getAll

* Implement registrant:delete

* Prettify error handling

* Add returnAll toggle and limit for all operations

* Preload webinars

* Preload webinar key in more fields

* Refactor getAll as handler

* Add descriptions for session

* Add descriptions for attendee

* Add descriptions for co-organizer

* Add descriptions for panelist

* Add descriptions for registrant

* Add descriptions for webinar

* Add 403 check for refresh token

* Fix defaults for webinar loader

* Add descriptions for webinar types

*  Improvements

* Remove unneeded return type annotation

* Add handler for continue on fail

* Remove 403 check in error handler

The Go To Webinar API returns 403 for a range of various errors, so this check ended up overriding more specific error messages not related to 403 Forbidden errors.

* Remove logging

*  Small improvement

*  Minor improvements

*  Improvements

*  Minor improvements

Co-authored-by: ricardo <ricardoespinoza105@gmail.com>
Co-authored-by: Jan Oberhauser <jan.oberhauser@gmail.com>
This commit is contained in:
Iván Ovejero 2021-02-22 04:49:00 -03:00 committed by GitHub
parent 1cb117d38a
commit 0dcaccefa7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
14 changed files with 3093 additions and 2 deletions

View file

@ -161,8 +161,9 @@ export function requestOAuth2(this: IAllExecuteFunctions, credentialsType: strin
return this.helpers.request!(newRequestOptions) return this.helpers.request!(newRequestOptions)
.catch(async (error: IResponseError) => { .catch(async (error: IResponseError) => {
// TODO: Check if also other codes are possible const statusCodeReturned = oAuth2Options?.tokenExpiredStatusCode === undefined ? 401 : oAuth2Options?.tokenExpiredStatusCode;
if (error.statusCode === 401) {
if (error.statusCode === statusCodeReturned) {
// Token is probably not valid anymore. So try refresh it. // Token is probably not valid anymore. So try refresh it.
const tokenRefreshOptions: IDataObject = {}; const tokenRefreshOptions: IDataObject = {};

View file

@ -0,0 +1,45 @@
import {
ICredentialType,
NodePropertyTypes,
} from 'n8n-workflow';
export class GoToWebinarOAuth2Api implements ICredentialType {
name = 'goToWebinarOAuth2Api';
extends = [
'oAuth2Api',
];
displayName = 'GoToWebinar OAuth2 API';
documentationUrl = 'goToWebinar';
properties = [
{
displayName: 'Authorization URL',
name: 'authUrl',
type: 'hidden' as NodePropertyTypes,
default: 'https://api.getgo.com/oauth/v2/authorize',
},
{
displayName: 'Access Token URL',
name: 'accessTokenUrl',
type: 'hidden' as NodePropertyTypes,
default: 'https://api.getgo.com/oauth/v2/token',
},
{
displayName: 'Scope',
name: 'scope',
type: 'hidden' as NodePropertyTypes,
default: '', // set when creating the OAuth client
},
{
displayName: 'Auth URI Query Parameters',
name: 'authQueryParameters',
type: 'hidden' as NodePropertyTypes,
default: '',
},
{
displayName: 'Authentication',
name: 'authentication',
type: 'hidden' as NodePropertyTypes,
default: 'header',
},
];
}

View file

@ -0,0 +1,286 @@
import {
IExecuteFunctions,
IHookFunctions,
} from 'n8n-core';
import {
IDataObject,
ILoadOptionsFunctions,
INodePropertyOptions,
} from 'n8n-workflow';
import {
OptionsWithUri,
} from 'request';
import * as moment from 'moment';
import * as losslessJSON from 'lossless-json';
/**
* Make an authenticated API request to GoToWebinar.
*/
export async function goToWebinarApiRequest(
this: IHookFunctions | IExecuteFunctions | ILoadOptionsFunctions,
method: string,
endpoint: string,
qs: IDataObject,
body: IDataObject | IDataObject[],
option: IDataObject = {},
) {
const operation = this.getNodeParameter('operation', 0) as string;
const resource = this.getNodeParameter('resource', 0) as string;
const options: OptionsWithUri = {
headers: {
'user-agent': 'n8n',
'Accept': 'application/json',
'Content-Type': 'application/json',
},
method,
uri: `https://api.getgo.com/G2W/rest/v2/${endpoint}`,
qs,
body: JSON.stringify(body),
json: false,
};
if (resource === 'session' && operation === 'getAll') {
options.headers!['Accept'] = 'application/vnd.citrix.g2wapi-v1.1+json';
}
if (['GET', 'DELETE'].includes(method)) {
delete options.body;
}
if (!Object.keys(qs).length) {
delete options.qs;
}
if (Object.keys(option)) {
Object.assign(options, option);
}
try {
const response = await this.helpers.requestOAuth2!.call(this, 'goToWebinarOAuth2Api', options, { tokenExpiredStatusCode: 403 });
if (response === '') {
return {};
}
// https://stackoverflow.com/questions/62190724/getting-gotowebinar-registrant
return losslessJSON.parse(response, convertLosslessNumber);
} catch (error) {
if (error?.response?.body) {
let errorMessage;
const body = JSON.parse(error.response.body);
if (Array.isArray(body.validationErrorCodes)) {
errorMessage = (body.validationErrorCodes as IDataObject[]).map((e) => e.description).join('|');
} else {
errorMessage = body.description;
}
throw new Error(`Go To Webinar error response [${error.statusCode}]: ${errorMessage}`);
}
throw error;
}
}
/**
* Make an authenticated API request to GoToWebinar and return all results.
*/
export async function goToWebinarApiRequestAllItems(
this: IHookFunctions | IExecuteFunctions | ILoadOptionsFunctions,
method: string,
endpoint: string,
qs: IDataObject,
body: IDataObject,
resource: string,
) {
const resourceToResponseKey: { [key: string]: string } = {
session: 'sessionInfoResources',
webinar: 'webinars',
};
const key = resourceToResponseKey[resource];
let returnData: IDataObject[] = [];
let responseData;
do {
responseData = await goToWebinarApiRequest.call(this, method, endpoint, qs, body);
if (responseData.page && parseInt(responseData.page.totalElements, 10) === 0) {
return [];
} else if (responseData._embedded && responseData._embedded[key]) {
returnData.push(...responseData._embedded[key]);
} else {
returnData.push(...responseData);
}
if (qs.limit && returnData.length >= qs.limit) {
returnData = returnData.splice(0, qs.limit as number);
return returnData;
}
} while (
responseData.totalElements && parseInt(responseData.totalElements, 10) > returnData.length
);
return returnData;
}
export async function handleGetAll(
this: IExecuteFunctions,
endpoint: string,
qs: IDataObject,
body: IDataObject,
resource: string) {
const returnAll = this.getNodeParameter('returnAll', 0) as boolean;
if (!returnAll) {
qs.limit = this.getNodeParameter('limit', 0) as number;
}
return await goToWebinarApiRequestAllItems.call(this, 'GET', endpoint, qs, body, resource);
}
export async function loadWebinars(this: ILoadOptionsFunctions) {
const { oauthTokenData } = this.getCredentials('goToWebinarOAuth2Api') as {
oauthTokenData: { account_key: string }
};
const endpoint = `accounts/${oauthTokenData.account_key}/webinars`;
const qs = {
fromTime: moment().subtract(1, 'years').format(),
toTime: moment().add(1, 'years').format(),
};
const resourceItems = await goToWebinarApiRequestAllItems.call(this, 'GET', endpoint, qs, {}, 'webinar');
const returnData: INodePropertyOptions[] = [];
resourceItems.forEach((item) => {
returnData.push({
name: item.subject as string,
value: item.webinarKey as string,
});
});
return returnData;
}
export async function loadWebinarSessions(this: ILoadOptionsFunctions) {
const { oauthTokenData } = this.getCredentials('goToWebinarOAuth2Api') as {
oauthTokenData: { organizer_key: string }
};
const webinarKey = this.getCurrentNodeParameter('webinarKey') as string;
const endpoint = `organizers/${oauthTokenData.organizer_key}/webinars/${webinarKey}/sessions`;
const resourceItems = await goToWebinarApiRequestAllItems.call(this, 'GET', endpoint, {}, {}, 'session');
const returnData: INodePropertyOptions[] = [];
resourceItems.forEach((item) => {
returnData.push({
name: `Date: ${moment(item.startTime as string).format('MM-DD-YYYY')} | From: ${moment(item.startTime as string).format('LT')} - To: ${moment(item.endTime as string).format('LT')}`,
value: item.sessionKey as string,
});
});
return returnData;
}
export async function loadRegistranSimpleQuestions(this: ILoadOptionsFunctions) {
const { oauthTokenData } = this.getCredentials('goToWebinarOAuth2Api') as {
oauthTokenData: { organizer_key: string }
};
const webinarkey = this.getNodeParameter('webinarKey') as string;
const endpoint = `organizers/${oauthTokenData.organizer_key}/webinars/${webinarkey}/registrants/fields`;
const { questions } = await goToWebinarApiRequest.call(this, 'GET', endpoint, {}, {});
const returnData: INodePropertyOptions[] = [];
questions.forEach((item: IDataObject) => {
if (item.type === 'shortAnswer') {
returnData.push({
name: item.question as string,
value: item.questionKey as string,
});
}
});
return returnData;
}
export async function loadAnswers(this: ILoadOptionsFunctions) {
const { oauthTokenData } = this.getCredentials('goToWebinarOAuth2Api') as {
oauthTokenData: { organizer_key: string }
};
const webinarKey = this.getCurrentNodeParameter('webinarKey') as string;
const questionKey = this.getCurrentNodeParameter('questionKey') as string;
const endpoint = `organizers/${oauthTokenData.organizer_key}/webinars/${webinarKey}/registrants/fields`;
const { questions } = await goToWebinarApiRequest.call(this, 'GET', endpoint, {}, {});
const returnData: INodePropertyOptions[] = [];
questions.forEach((item: IDataObject) => {
if (item.type === 'multiChoice' && item.questionKey === questionKey) {
for (const answer of item.answers as IDataObject[]) {
returnData.push({
name: answer.answer as string,
value: answer.answerKey as string,
});
}
}
});
return returnData;
}
export async function loadRegistranMultiChoiceQuestions(this: ILoadOptionsFunctions) {
const { oauthTokenData } = this.getCredentials('goToWebinarOAuth2Api') as {
oauthTokenData: { organizer_key: string }
};
const webinarkey = this.getNodeParameter('webinarKey') as string;
const endpoint = `organizers/${oauthTokenData.organizer_key}/webinars/${webinarkey}/registrants/fields`;
const { questions } = await goToWebinarApiRequest.call(this, 'GET', endpoint, {}, {});
const returnData: INodePropertyOptions[] = [];
questions.forEach((item: IDataObject) => {
if (item.type === 'multipleChoice') {
returnData.push({
name: item.question as string,
value: item.questionKey as string,
});
}
});
return returnData;
}
// tslint:disable-next-line: no-any
function convertLosslessNumber(key: any, value: any) {
if (value && value.isLosslessNumber) {
return value.toString();
}
else {
return value;
}
}

View file

@ -0,0 +1,690 @@
import {
IExecuteFunctions,
} from 'n8n-core';
import {
IDataObject,
ILoadOptionsFunctions,
INodeExecutionData,
INodePropertyOptions,
INodeType,
INodeTypeDescription,
} from 'n8n-workflow';
import {
attendeeFields,
attendeeOperations,
coorganizerFields,
coorganizerOperations,
panelistFields,
panelistOperations,
registrantFields,
registrantOperations,
sessionFields,
sessionOperations,
webinarFields,
webinarOperations,
} from './descriptions';
import {
goToWebinarApiRequest,
goToWebinarApiRequestAllItems,
handleGetAll,
loadAnswers,
loadRegistranMultiChoiceQuestions,
loadRegistranSimpleQuestions,
loadWebinars,
loadWebinarSessions,
} from './GenericFunctions';
import {
isEmpty,
omit,
} from 'lodash';
import * as moment from 'moment-timezone';
export class GoToWebinar implements INodeType {
description: INodeTypeDescription = {
displayName: 'GoToWebinar',
name: 'GoToWebinar',
icon: 'file:gotowebinar.svg',
group: ['transform'],
version: 1,
subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
description: 'Consume the GoToWebinar API',
defaults: {
name: 'GoToWebinar',
color: '#0097e1',
},
inputs: ['main'],
outputs: ['main'],
credentials: [
{
name: 'goToWebinarOAuth2Api',
required: true,
},
],
properties: [
{
displayName: 'Resource',
name: 'resource',
type: 'options',
options: [
{
name: 'Attendee',
value: 'attendee',
},
{
name: 'Co-Organizer',
value: 'coorganizer',
},
{
name: 'Panelist',
value: 'panelist',
},
{
name: 'Registrant',
value: 'registrant',
},
{
name: 'Session',
value: 'session',
},
{
name: 'Webinar',
value: 'webinar',
},
],
default: 'attendee',
description: 'Resource to consume',
},
...attendeeOperations,
...attendeeFields,
...coorganizerOperations,
...coorganizerFields,
...panelistOperations,
...panelistFields,
...registrantOperations,
...registrantFields,
...sessionOperations,
...sessionFields,
...webinarOperations,
...webinarFields,
],
};
methods = {
loadOptions: {
async getWebinars(this: ILoadOptionsFunctions) {
return await loadWebinars.call(this);
},
async getAnswers(this: ILoadOptionsFunctions) {
return await loadAnswers.call(this);
},
async getWebinarSessions(this: ILoadOptionsFunctions) {
return await loadWebinarSessions.call(this);
},
// Get all the timezones to display them to user so that he can
// select them easily
async getTimezones(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
const returnData: INodePropertyOptions[] = [];
for (const timezone of moment.tz.names()) {
const timezoneName = timezone;
const timezoneId = timezone;
returnData.push({
name: timezoneName,
value: timezoneId,
});
}
return returnData;
},
async getRegistranSimpleQuestions(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
return await loadRegistranSimpleQuestions.call(this);
},
async getRegistranMultiChoiceQuestions(this: ILoadOptionsFunctions): Promise<INodePropertyOptions[]> {
return await loadRegistranMultiChoiceQuestions.call(this);
},
},
};
async execute(this: IExecuteFunctions): Promise<INodeExecutionData[][]> {
const items = this.getInputData();
const resource = this.getNodeParameter('resource', 0) as string;
const operation = this.getNodeParameter('operation', 0) as string;
let responseData;
const returnData: IDataObject[] = [];
const { oauthTokenData } = this.getCredentials('goToWebinarOAuth2Api') as {
oauthTokenData: { account_key: string, organizer_key: string }
};
const accountKey = oauthTokenData.account_key;
const organizerKey = oauthTokenData.organizer_key;
for (let i = 0; i < items.length; i++) {
try {
if (resource === 'attendee') {
// *********************************************************************
// attendee
// *********************************************************************
// https://developer.goto.com/GoToWebinarV2/#tag/Attendees
if (operation === 'get') {
// ----------------------------------
// attendee: get
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const sessionKey = this.getNodeParameter('sessionKey', i) as string;
const registrantKey = this.getNodeParameter('registrantKey', i) as string;
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/sessions/${sessionKey}/attendees/${registrantKey}`;
responseData = await goToWebinarApiRequest.call(this, 'GET', endpoint, {}, {});
} else if (operation === 'getAll') {
// ----------------------------------
// attendee: getAll
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const sessionKey = this.getNodeParameter('sessionKey', i) as string;
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/sessions/${sessionKey}/attendees`;
responseData = await handleGetAll.call(this, endpoint, {}, {}, resource);
} else if (operation === 'getDetails') {
// ----------------------------------
// attendee: getDetails
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const sessionKey = this.getNodeParameter('sessionKey', i) as string;
const registrantKey = this.getNodeParameter('registrantKey', i) as string;
const details = this.getNodeParameter('details', i) as string;
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/sessions/${sessionKey}/attendees/${registrantKey}/${details}`;
responseData = await goToWebinarApiRequest.call(this, 'GET', endpoint, {}, {});
}
} else if (resource === 'coorganizer') {
// *********************************************************************
// coorganizer
// *********************************************************************
// https://developer.goto.com/GoToWebinarV2/#tag/Co-organizers
if (operation === 'create') {
// ----------------------------------
// coorganizer: create
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const body = {
external: this.getNodeParameter('isExternal', i) as boolean,
} as IDataObject;
if (body.external === false) {
body.organizerKey = this.getNodeParameter('organizerKey', i) as string;
}
if (body.external === true) {
body.givenName = this.getNodeParameter('givenName', i) as string;
body.email = this.getNodeParameter('email', i) as string;
}
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/coorganizers`;
responseData = await goToWebinarApiRequest.call(this, 'POST', endpoint, {}, [body]);
} else if (operation === 'delete') {
// ----------------------------------
// coorganizer: delete
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const coorganizerKey = this.getNodeParameter('coorganizerKey', i) as string;
const qs = {
external: this.getNodeParameter('isExternal', i) as boolean,
};
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/coorganizers/${coorganizerKey}`;
responseData = await goToWebinarApiRequest.call(this, 'DELETE', endpoint, qs, {});
responseData = { success: true };
} else if (operation === 'getAll') {
// ----------------------------------
// coorganizer: getAll
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/coorganizers`;
responseData = await handleGetAll.call(this, endpoint, {}, {}, resource);
} else if (operation === 'reinvite') {
// ----------------------------------
// coorganizer: reinvite
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const coorganizerKey = this.getNodeParameter('coorganizerKey', i) as string;
const qs = {
external: this.getNodeParameter('isExternal', i) as boolean,
};
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/coorganizers/${coorganizerKey}/resendInvitation`;
responseData = await goToWebinarApiRequest.call(this, 'POST', endpoint, qs, {});
responseData = { success: true };
}
} else if (resource === 'panelist') {
// *********************************************************************
// panelist
// *********************************************************************
// https://developer.goto.com/GoToWebinarV2/#tag/Panelists
if (operation === 'create') {
// ----------------------------------
// panelist: create
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const body = [
{
name: this.getNodeParameter('name', i) as string,
email: this.getNodeParameter('email', i) as string,
},
] as IDataObject[];
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/panelists`;
responseData = await goToWebinarApiRequest.call(this, 'POST', endpoint, {}, body);
} else if (operation === 'delete') {
// ----------------------------------
// panelist: delete
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const panelistKey = this.getNodeParameter('panelistKey', i) as string;
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/panelists/${panelistKey}`;
responseData = await goToWebinarApiRequest.call(this, 'DELETE', endpoint, {}, {});
responseData = { success: true };
} else if (operation === 'getAll') {
// ----------------------------------
// panelist: getAll
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/panelists`;
responseData = await handleGetAll.call(this, endpoint, {}, {}, resource);
} else if (operation === 'reinvite') {
// ----------------------------------
// panelist: reinvite
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const panelistKey = this.getNodeParameter('panelistKey', i) as string;
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/panelists/${panelistKey}/resendInvitation`;
responseData = await goToWebinarApiRequest.call(this, 'POST', endpoint, {}, {});
responseData = { success: true };
}
} else if (resource === 'registrant') {
// *********************************************************************
// registrant
// *********************************************************************
// https://developer.goto.com/GoToWebinarV2/#tag/Registrants
if (operation === 'create') {
// ----------------------------------
// registrant: create
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const qs = {} as IDataObject;
const body = {
firstName: this.getNodeParameter('firstName', i) as string,
lastName: this.getNodeParameter('lastName', i) as string,
email: this.getNodeParameter('email', i) as string,
responses: [],
} as IDataObject;
let additionalFields = this.getNodeParameter('additionalFields', i) as Partial<{
resendConfirmation: boolean,
fullAddress: {
details: { [key: string]: string }
}
simpleResponses: [
{ [key: string]: string }
],
multiChoiceResponses: [
{ [key: string]: string }
],
}>;
if (additionalFields.resendConfirmation) {
qs.resendConfirmation = additionalFields.resendConfirmation;
additionalFields = omit(additionalFields, ['resendConfirmation']);
}
if (additionalFields.fullAddress) {
Object.assign(body, additionalFields.fullAddress.details);
additionalFields = omit(additionalFields, ['fullAddress']);
}
if (additionalFields.simpleResponses) {
//@ts-ignore
body.responses.push(...additionalFields.simpleResponses.details);
additionalFields = omit(additionalFields, ['simpleResponses']);
}
if (additionalFields.multiChoiceResponses) {
//@ts-ignore
body.responses.push(...additionalFields.multiChoiceResponses.details);
additionalFields = omit(additionalFields, ['multiChoiceResponses']);
}
Object.assign(body, additionalFields);
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/registrants`;
responseData = await goToWebinarApiRequest.call(this, 'POST', endpoint, qs, body);
} else if (operation === 'delete') {
// ----------------------------------
// registrant: delete
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const registrantKey = this.getNodeParameter('registrantKey', i) as string;
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/registrants/${registrantKey}`;
responseData = await goToWebinarApiRequest.call(this, 'DELETE', endpoint, {}, {});
responseData = { success: true };
} else if (operation === 'get') {
// ----------------------------------
// registrant: get
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const registrantKey = this.getNodeParameter('registrantKey', i) as string;
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/registrants/${registrantKey}`;
responseData = await goToWebinarApiRequest.call(this, 'GET', endpoint, {}, {});
} else if (operation === 'getAll') {
// ----------------------------------
// registrant: getAll
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/registrants`;
responseData = await handleGetAll.call(this, endpoint, {}, {}, resource);
}
} else if (resource === 'session') {
// *********************************************************************
// session
// *********************************************************************
// https://developer.goto.com/GoToWebinarV2/#tag/Sessions
if (operation === 'get') {
// ----------------------------------
// session: get
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const sessionKey = this.getNodeParameter('sessionKey', i) as string;
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/sessions/${sessionKey}`;
responseData = await goToWebinarApiRequest.call(this, 'GET', endpoint, {}, {});
} else if (operation === 'getAll') {
// ----------------------------------
// session: getAll
// ----------------------------------
const qs = {} as IDataObject;
const returnAll = this.getNodeParameter('returnAll', 0) as boolean;
if (!returnAll) {
qs.limit = this.getNodeParameter('limit', 0) as number;
}
const {
webinarKey,
times,
} = this.getNodeParameter('additionalFields', i) as {
filterByWebinar: boolean,
webinarKey: string,
times: {
timesProperties: { [key: string]: string }
}
};
if (times) {
qs.fromTime = moment(times.timesProperties.fromTime).format();
qs.toTime = moment(times.timesProperties.toTime).format();
} else {
qs.fromTime = moment().subtract(1, 'years').format();
qs.toTime = moment().format();
}
if (webinarKey !== undefined) {
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/sessions`;
responseData = await goToWebinarApiRequestAllItems.call(this, 'GET', endpoint, qs, {}, resource);
} else {
const endpoint = `organizers/${organizerKey}/sessions`;
responseData = await goToWebinarApiRequestAllItems.call(this, 'GET', endpoint, qs, {}, resource);
}
} else if (operation === 'getDetails') {
// ----------------------------------
// session: getDetails
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const sessionKey = this.getNodeParameter('sessionKey', i) as string;
const details = this.getNodeParameter('details', i) as string;
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}/sessions/${sessionKey}/${details}`;
responseData = await goToWebinarApiRequest.call(this, 'GET', endpoint, {}, {});
}
} else if (resource === 'webinar') {
// *********************************************************************
// webinar
// *********************************************************************
// https://developer.goto.com/GoToWebinarV2/#tag/Webinars
if (operation === 'create') {
// ----------------------------------
// webinar: create
// ----------------------------------
const timesProperties = this.getNodeParameter('times.timesProperties', i, []) as IDataObject;
const body = {
subject: this.getNodeParameter('subject', i) as string,
times: timesProperties,
} as IDataObject;
const additionalFields = this.getNodeParameter('additionalFields', i) as IDataObject;
Object.assign(body, additionalFields);
const endpoint = `organizers/${organizerKey}/webinars`;
responseData = await goToWebinarApiRequest.call(this, 'POST', endpoint, {}, body);
} else if (operation === 'delete') {
// ----------------------------------
// webinar: delete
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const { sendCancellationEmails } = this.getNodeParameter('additionalFields', i) as IDataObject;
const qs = {} as IDataObject;
if (sendCancellationEmails) {
qs.sendCancellationEmails = sendCancellationEmails;
}
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}`;
await goToWebinarApiRequest.call(this, 'DELETE', endpoint, qs, {});
responseData = { success: true };
} else if (operation === 'get') {
// ----------------------------------
// webinar: get
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}`;
responseData = await goToWebinarApiRequest.call(this, 'GET', endpoint, {}, {});
} else if (operation === 'getAll') {
// ----------------------------------
// webinar: getAll
// ----------------------------------
const qs = {} as IDataObject;
const returnAll = this.getNodeParameter('returnAll', 0) as boolean;
if (!returnAll) {
qs.limit = this.getNodeParameter('limit', 0) as number;
}
const { times } = this.getNodeParameter('additionalFields', i) as {
times: {
timesProperties: { [key: string]: string }
}
};
if (times) {
qs.fromTime = moment(times.timesProperties.fromTime).format();
qs.toTime = moment(times.timesProperties.toTime).format();
} else {
qs.fromTime = moment().subtract(1, 'years').format();
qs.toTime = moment().format();
}
const endpoint = `accounts/${accountKey}/webinars`;
responseData = await goToWebinarApiRequestAllItems.call(this, 'GET', endpoint, qs, {}, resource);
} else if (operation === 'update') {
// ----------------------------------
// webinar: update
// ----------------------------------
const webinarKey = this.getNodeParameter('webinarKey', i) as string;
const qs = {
notifyParticipants: this.getNodeParameter('notifyParticipants', i) as boolean,
} as IDataObject;
let body = {};
let updateFields = this.getNodeParameter('updateFields', i) as IDataObject;
if (updateFields.times) {
const { times } = updateFields as {
times: { timesProperties: Array<{ startTime: string, endTime: string }> }
};
body = {
times: times.timesProperties,
} as IDataObject;
updateFields = omit(updateFields, ['times']);
}
Object.assign(body, updateFields);
if (isEmpty(updateFields)) {
throw new Error(`Please enter at least one field to update for the ${resource}.`);
}
const endpoint = `organizers/${organizerKey}/webinars/${webinarKey}`;
await goToWebinarApiRequest.call(this, 'PUT', endpoint, qs, body);
responseData = { success: true };
}
}
} catch (error) {
if (this.continueOnFail()) {
returnData.push({ error: error.message });
continue;
}
throw error;
}
Array.isArray(responseData)
? returnData.push(...responseData)
: returnData.push(responseData);
}
return [this.helpers.returnJsonArray(returnData)];
}
}

View file

@ -0,0 +1,203 @@
import {
INodeProperties,
} from 'n8n-workflow';
export const attendeeOperations = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
default: 'get',
description: 'Operation to perform',
options: [
{
name: 'Get',
value: 'get',
},
{
name: 'Get All',
value: 'getAll',
},
{
name: 'Get Details',
value: 'getDetails',
},
],
displayOptions: {
show: {
resource: [
'attendee',
],
},
},
},
] as INodeProperties[];
export const attendeeFields = [
// ----------------------------------
// attendee: shared fields
// ----------------------------------
{
displayName: 'Webinar Key',
name: 'webinarKey',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getWebinars',
},
required: true,
default: '',
description: 'Key of the webinar that the attendee attended.',
displayOptions: {
show: {
resource: [
'attendee',
],
},
},
},
{
displayName: 'Session Key',
name: 'sessionKey',
type: 'options',
required: true,
typeOptions: {
loadOptionsMethod: 'getWebinarSessions',
loadOptionsDependsOn: [
'webinarKey',
],
},
default: '',
description: 'Key of the session that the attendee attended.',
displayOptions: {
show: {
resource: [
'attendee',
],
},
},
},
// ----------------------------------
// attendee: get
// ----------------------------------
{
displayName: 'Registrant Key',
name: 'registrantKey',
type: 'string',
required: true,
default: '',
description: 'Registrant key of the attendee at the webinar session.',
displayOptions: {
show: {
resource: [
'attendee',
],
operation: [
'get',
],
},
},
},
// ----------------------------------
// attendee: getDetails
// ----------------------------------
{
displayName: 'Registrant Key',
name: 'registrantKey',
type: 'string',
required: true,
default: '',
description: 'Registrant key of the attendee at the webinar session.',
displayOptions: {
show: {
resource: [
'attendee',
],
operation: [
'getDetails',
],
},
},
},
{
displayName: 'Details',
name: 'details',
type: 'options',
required: true,
default: '',
description: 'The details to retrieve for the attendee.',
options: [
{
name: 'Polls',
value: 'polls',
description: 'Poll answers from the attendee in a webinar session.',
},
{
name: 'Questions',
value: 'questions',
description: 'Questions asked by the attendee in a webinar session.',
},
{
name: 'Survey Answers',
value: 'surveyAnswers',
description: 'Survey answers from the attendee in a webinar session.',
},
],
displayOptions: {
show: {
resource: [
'attendee',
],
operation: [
'getDetails',
],
},
},
},
// ----------------------------------
// attendee: getAll
// ----------------------------------
{
displayName: 'Return All',
name: 'returnAll',
type: 'boolean',
default: false,
description: 'Return all results.',
displayOptions: {
show: {
resource: [
'attendee',
],
operation: [
'getAll',
],
},
},
},
{
displayName: 'Limit',
name: 'limit',
type: 'number',
default: 10,
description: 'The number of results to return.',
typeOptions: {
minValue: 1,
maxValue: 100,
},
displayOptions: {
show: {
resource: [
'attendee',
],
operation: [
'getAll',
],
returnAll: [
false,
],
},
},
},
] as INodeProperties[];

View file

@ -0,0 +1,327 @@
import {
INodeProperties,
} from 'n8n-workflow';
export const coorganizerOperations = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
default: 'get',
description: 'Operation to perform',
options: [
{
name: 'Create',
value: 'create',
},
{
name: 'Delete',
value: 'delete',
},
{
name: 'Get All',
value: 'getAll',
},
{
name: 'Reinvite',
value: 'reinvite',
},
],
displayOptions: {
show: {
resource: [
'coorganizer',
],
},
},
},
] as INodeProperties[];
export const coorganizerFields = [
// ----------------------------------
// coorganizer: create
// ----------------------------------
{
displayName: 'Webinar Key',
name: 'webinarKey',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getWebinars',
},
required: true,
default: [],
description: 'Key of the webinar that the co-organizer is hosting.',
displayOptions: {
show: {
resource: [
'coorganizer',
],
operation: [
'create',
],
},
},
},
{
displayName: 'Is External',
name: 'isExternal',
type: 'boolean',
required: true,
default: false,
description: 'Whether the co-organizer has no GoToWebinar account.',
displayOptions: {
show: {
resource: [
'coorganizer',
],
operation: [
'create',
],
},
},
},
{
displayName: 'Organizer Key',
name: 'organizerKey',
type: 'string',
description: 'The co-organizer\'s organizer key for the webinar.',
displayOptions: {
show: {
resource: [
'coorganizer',
],
operation: [
'create',
],
isExternal: [
false,
],
},
},
},
{
displayName: 'Given Name',
name: 'givenName',
type: 'string',
default: '',
description: 'The co-organizer\'s given name.',
displayOptions: {
show: {
resource: [
'coorganizer',
],
operation: [
'create',
],
isExternal: [
true,
],
},
},
},
{
displayName: 'Email',
name: 'email',
type: 'string',
default: '',
description: 'The co-organizer\'s email address.',
displayOptions: {
show: {
resource: [
'coorganizer',
],
operation: [
'create',
],
isExternal: [
true,
],
},
},
},
// ----------------------------------
// coorganizer: delete
// ----------------------------------
{
displayName: 'Webinar Key',
name: 'webinarKey',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getWebinars',
},
required: true,
default: [],
description: 'Key of the webinar to delete.',
displayOptions: {
show: {
resource: [
'coorganizer',
],
operation: [
'delete',
],
},
},
},
{
displayName: 'Co-Organizer Key',
name: 'coorganizerKey',
type: 'string',
default: '',
description: 'Key of the co-organizer to delete.',
displayOptions: {
show: {
resource: [
'coorganizer',
],
operation: [
'delete',
],
},
},
},
{
displayName: 'Is External',
name: 'isExternal',
type: 'boolean',
required: true,
default: false,
displayOptions: {
show: {
resource: [
'coorganizer',
],
operation: [
'delete',
],
},
},
description: `By default only internal co-organizers (with a GoToWebinar account) can be deleted.</br>
If you want to use this call for external co-organizers you have to set this parameter to 'true'.`,
},
// ----------------------------------
// coorganizer: getAll
// ----------------------------------
{
displayName: 'Webinar Key',
name: 'webinarKey',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getWebinars',
},
required: true,
default: [],
description: 'Key of the webinar to retrieve all co-organizers from.',
displayOptions: {
show: {
resource: [
'coorganizer',
],
operation: [
'getAll',
],
},
},
},
{
displayName: 'Return All',
name: 'returnAll',
type: 'boolean',
default: false,
description: 'Return all results.',
displayOptions: {
show: {
resource: [
'coorganizer',
],
operation: [
'getAll',
],
},
},
},
{
displayName: 'Limit',
name: 'limit',
type: 'number',
default: 10,
description: 'The number of results to return.',
typeOptions: {
minValue: 1,
maxValue: 100,
},
displayOptions: {
show: {
resource: [
'coorganizer',
],
operation: [
'getAll',
],
returnAll: [
false,
],
},
},
},
// ----------------------------------
// coorganizer: reinvite
// ----------------------------------
{
displayName: 'Webinar Key',
name: 'webinarKey',
type: 'string',
required: true,
default: '',
description: `By default only internal co-organizers (with a GoToWebinar account) can be deleted.</br>
If you want to use this call for external co-organizers you have to set this parameter to 'true'.`,
displayOptions: {
show: {
resource: [
'coorganizer',
],
operation: [
'reinvite',
],
},
},
},
{
displayName: 'Co-Organizer Key',
name: 'coorganizerKey',
type: 'string',
default: '',
description: 'Key of the co-organizer to reinvite.',
displayOptions: {
show: {
resource: [
'coorganizer',
],
operation: [
'reinvite',
],
},
},
},
{
displayName: 'Is External',
name: 'isExternal',
type: 'boolean',
required: true,
default: false,
description: 'Whether the co-organizer has no GoToWebinar account.',
displayOptions: {
show: {
resource: [
'coorganizer',
],
operation: [
'reinvite',
],
},
},
},
] as INodeProperties[];

View file

@ -0,0 +1,253 @@
import {
INodeProperties,
} from 'n8n-workflow';
export const panelistOperations = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
default: 'get',
description: 'Operation to perform',
options: [
{
name: 'Create',
value: 'create',
},
{
name: 'Delete',
value: 'delete',
},
{
name: 'Get All',
value: 'getAll',
},
{
name: 'Reinvite',
value: 'reinvite',
},
],
displayOptions: {
show: {
resource: [
'panelist',
],
},
},
},
] as INodeProperties[];
export const panelistFields = [
// ----------------------------------
// panelist: create
// ----------------------------------
{
displayName: 'Name',
name: 'name',
type: 'string',
required: true,
default: '',
description: 'Name of the panelist to create.',
displayOptions: {
show: {
resource: [
'panelist',
],
operation: [
'create',
],
},
},
},
{
displayName: 'Email',
name: 'email',
type: 'string',
required: true,
default: '',
description: 'Email address of the panelist to create.',
displayOptions: {
show: {
resource: [
'panelist',
],
operation: [
'create',
],
},
},
},
{
displayName: 'Webinar Key',
name: 'webinarKey',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getWebinars',
},
required: true,
default: [],
description: 'Key of the webinar that the panelist will present at.',
displayOptions: {
show: {
resource: [
'panelist',
],
operation: [
'create',
],
},
},
},
// ----------------------------------
// panelist: getAll
// ----------------------------------
{
displayName: 'Webinar Key',
name: 'webinarKey',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getWebinars',
},
required: true,
default: [],
description: 'Key of the webinar to retrieve all panelists from.',
displayOptions: {
show: {
resource: [
'panelist',
],
operation: [
'getAll',
],
},
},
},
{
displayName: 'Return All',
name: 'returnAll',
type: 'boolean',
default: false,
description: 'Return all results.',
displayOptions: {
show: {
resource: [
'panelist',
],
operation: [
'getAll',
],
},
},
},
{
displayName: 'Limit',
name: 'limit',
type: 'number',
default: 10,
description: 'The number of results to return.',
typeOptions: {
minValue: 1,
maxValue: 100,
},
displayOptions: {
show: {
resource: [
'panelist',
],
operation: [
'getAll',
],
returnAll: [
false,
],
},
},
},
// ----------------------------------
// panelist: delete
// ----------------------------------
{
displayName: 'Webinar Key',
name: 'webinarKey',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getWebinars',
},
required: true,
default: [],
description: 'Key of the webinar to delete the panelist from.',
displayOptions: {
show: {
resource: [
'panelist',
],
operation: [
'delete',
],
},
},
},
{
displayName: 'Panelist Key',
name: 'panelistKey',
type: 'string',
required: true,
default: '',
description: 'Key of the panelist to delete.',
displayOptions: {
show: {
resource: [
'panelist',
],
operation: [
'delete',
],
},
},
},
// ----------------------------------
// panelist: reinvite
// ----------------------------------
{
displayName: 'Webinar Key',
name: 'webinarKey',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getWebinars',
},
required: true,
default: [],
description: 'Key of the webinar to reinvite the panelist to.',
displayOptions: {
show: {
resource: [
'panelist',
],
operation: [
'reinvite',
],
},
},
},
{
displayName: 'Panelist Key',
name: 'panelistKey',
type: 'string',
required: true,
default: '',
description: 'Key of the panelist to reinvite.',
displayOptions: {
show: {
resource: [
'panelist',
],
operation: [
'reinvite',
],
},
},
},
] as INodeProperties[];

View file

@ -0,0 +1,475 @@
import {
INodeProperties,
} from 'n8n-workflow';
export const registrantOperations = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
default: 'get',
description: 'Operation to perform',
options: [
{
name: 'Create',
value: 'create',
},
{
name: 'Delete',
value: 'delete',
},
{
name: 'Get',
value: 'get',
},
{
name: 'Get All',
value: 'getAll',
},
],
displayOptions: {
show: {
resource: [
'registrant',
],
},
},
},
] as INodeProperties[];
export const registrantFields = [
// ----------------------------------
// registrant: create
// ----------------------------------
{
displayName: 'Webinar Key',
name: 'webinarKey',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getWebinars',
},
required: true,
default: [],
description: 'Key of the webinar of the registrant to create.',
displayOptions: {
show: {
resource: [
'registrant',
],
operation: [
'create',
],
},
},
},
{
displayName: 'First Name',
name: 'firstName',
type: 'string',
default: '',
description: 'First name of the registrant to create.',
displayOptions: {
show: {
resource: [
'registrant',
],
operation: [
'create',
],
},
},
},
{
displayName: 'Last Name',
name: 'lastName',
type: 'string',
default: '',
description: 'Last name of the registrant to create.',
displayOptions: {
show: {
resource: [
'registrant',
],
operation: [
'create',
],
},
},
},
{
displayName: 'Email',
name: 'email',
type: 'string',
default: '',
description: 'Email address of the registrant to create.',
displayOptions: {
show: {
resource: [
'registrant',
],
operation: [
'create',
],
},
},
},
{
displayName: 'Additional Fields',
name: 'additionalFields',
type: 'collection',
placeholder: 'Add Field',
displayOptions: {
show: {
resource: [
'registrant',
],
operation: [
'create',
],
},
},
default: {},
options: [
{
displayName: 'Full Address',
name: 'fullAddress',
placeholder: 'Add Address Fields',
type: 'fixedCollection',
description: 'Full address of the registrant to create.',
default: {},
options: [
{
displayName: 'Details',
name: 'details',
values: [
{
displayName: 'Address',
name: 'address',
type: 'string',
default: '',
},
{
displayName: 'City',
name: 'city',
type: 'string',
default: '',
},
{
displayName: 'State',
name: 'state',
type: 'string',
default: '',
},
{
displayName: 'Zip Code',
name: 'zipCode',
type: 'string',
default: '',
},
{
displayName: 'Country',
name: 'country',
type: 'string',
default: '',
},
],
},
],
},
{
displayName: 'Industry',
name: 'industry',
type: 'string',
default: '',
description: 'The type of industry the registrant\'s organization belongs to.',
},
{
displayName: 'Job Title',
name: 'jobTitle',
type: 'string',
default: '',
},
{
displayName: 'MultiChoice Responses',
name: 'multiChoiceResponses',
placeholder: 'Add MultiChoice Response',
type: 'fixedCollection',
typeOptions: {
multipleValues: true,
},
description: 'Set the answers to all questions.',
default: {},
options: [
{
displayName: 'Details',
name: 'details',
values: [
{
displayName: 'Question Key',
name: 'questionKey',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getRegistranMultiChoiceQuestions',
loadOptionsDependsOn: [
'webinarKey',
],
},
default: '',
},
{
displayName: 'Answer Key',
name: 'AnswerKey',
type: 'string',
default: '',
description: 'Answer ID of the question.',
},
],
},
],
},
{
displayName: 'Number of Employees',
name: 'numberOfEmployees',
type: 'string',
default: '',
description: 'The size in employees of the registrant\'s organization.',
},
{
displayName: 'Organization',
name: 'organization',
type: 'string',
default: '',
},
{
displayName: 'Telephone',
name: 'phone',
type: 'string',
default: '',
},
{
displayName: 'Purchasing Role',
name: 'purchasingRole',
type: 'string',
default: '',
description: 'Registrant\'s role in purchasing the product.',
},
{
displayName: 'Purchasing Time Frame',
name: 'purchasingTimeFrame',
type: 'string',
default: '',
description: 'Time frame within which the product will be purchased.',
},
{
displayName: 'Questions and Comments',
name: 'questionsAndComments',
type: 'string',
default: '',
description: 'Questions or comments made by the registrant during registration.',
},
{
displayName: 'Resend Confirmation',
name: 'resendConfirmation',
type: 'boolean',
default: false,
},
{
displayName: 'Simple Responses',
name: 'simpleResponses',
placeholder: 'Add Simple Response',
type: 'fixedCollection',
typeOptions: {
multipleValues: true,
},
description: 'Set the answers to all questions.',
default: {},
options: [
{
displayName: 'Details',
name: 'details',
values: [
{
displayName: 'Question Key',
name: 'questionKey',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getRegistranSimpleQuestions',
loadOptionsDependsOn: [
'webinarKey',
],
},
default: '',
},
{
displayName: 'Response Text',
name: 'responseText',
type: 'string',
default: '',
description: 'Text of the response to the question.',
},
],
},
],
},
{
displayName: 'Source',
name: 'source',
type: 'string',
default: '',
description: 'The source that led to the registration.',
},
],
},
// ----------------------------------
// registrant: getAll
// ----------------------------------
{
displayName: 'Webinar Key',
name: 'webinarKey',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getWebinars',
},
required: true,
default: [],
description: 'The key of the webinar to retrieve registrants from.',
displayOptions: {
show: {
resource: [
'registrant',
],
operation: [
'getAll',
],
},
},
},
{
displayName: 'Return All',
name: 'returnAll',
type: 'boolean',
default: false,
description: 'Return all results.',
displayOptions: {
show: {
resource: [
'registrant',
],
operation: [
'getAll',
],
},
},
},
{
displayName: 'Limit',
name: 'limit',
type: 'number',
default: 10,
description: 'The number of results to return.',
typeOptions: {
minValue: 1,
maxValue: 100,
},
displayOptions: {
show: {
resource: [
'registrant',
],
operation: [
'getAll',
],
returnAll: [
false,
],
},
},
},
// ----------------------------------
// registrant: delete
// ----------------------------------
{
displayName: 'Webinar Key',
name: 'webinarKey',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getWebinars',
},
required: true,
default: [],
description: 'Key of the webinar of the registrant to delete.',
displayOptions: {
show: {
resource: [
'registrant',
],
operation: [
'delete',
],
},
},
},
{
displayName: 'Registrant Key',
name: 'registrantKey',
type: 'string',
required: true,
default: '',
description: 'Key of the registrant to delete.',
displayOptions: {
show: {
resource: [
'registrant',
],
operation: [
'delete',
],
},
},
},
// ----------------------------------
// registrant: get
// ----------------------------------
{
displayName: 'Webinar Key',
name: 'webinarKey',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getWebinars',
},
required: true,
default: [],
description: 'Key of the webinar of the registrant to retrieve.',
displayOptions: {
show: {
resource: [
'registrant',
],
operation: [
'get',
],
},
},
},
{
displayName: 'Registrant Key',
name: 'registrantKey',
type: 'string',
required: true,
default: '',
description: 'Key of the registrant to retrieve.',
displayOptions: {
show: {
resource: [
'registrant',
],
operation: [
'get',
],
},
},
},
] as INodeProperties[];

View file

@ -0,0 +1,226 @@
import {
INodeProperties,
} from 'n8n-workflow';
export const sessionOperations = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
default: 'get',
description: 'Operation to perform',
options: [
{
name: 'Get',
value: 'get',
},
{
name: 'Get All',
value: 'getAll',
},
{
name: 'Get Details',
value: 'getDetails',
},
],
displayOptions: {
show: {
resource: [
'session',
],
},
},
},
] as INodeProperties[];
export const sessionFields = [
// ----------------------------------
// session: getAll
// ----------------------------------
{
displayName: 'Return All',
name: 'returnAll',
type: 'boolean',
default: false,
description: 'Return all results.',
displayOptions: {
show: {
resource: [
'session',
],
operation: [
'getAll',
],
},
},
},
{
displayName: 'Limit',
name: 'limit',
type: 'number',
default: 10,
description: 'The number of results to return.',
typeOptions: {
minValue: 1,
maxValue: 100,
},
displayOptions: {
show: {
resource: [
'session',
],
operation: [
'getAll',
],
returnAll: [
false,
],
},
},
},
{
displayName: 'Additional Fields',
name: 'additionalFields',
type: 'collection',
placeholder: 'Add Field',
displayOptions: {
show: {
resource: [
'session',
],
operation: [
'getAll',
],
},
},
default: {},
options: [
{
displayName: 'Time Range',
name: 'times',
type: 'fixedCollection',
placeholder: 'Add Time Range',
required: true,
default: {},
options: [
{
displayName: 'Times Properties',
name: 'timesProperties',
values: [
{
displayName: 'Start Time',
name: 'fromTime',
type: 'dateTime',
description: 'Start of the datetime range for the session.',
default: '',
},
{
displayName: 'End Time',
name: 'toTime',
type: 'dateTime',
description: 'End of the datetime range for the session.',
default: '',
},
],
},
],
},
{
displayName: 'Webinar Key',
name: 'webinarKey',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getWebinars',
},
default: {},
description: 'Webinar by which to filter the sessions to retrieve.',
},
],
},
// ----------------------------------
// session: shared fields
// ----------------------------------
{
displayName: 'Webinar Key',
name: 'webinarKey',
type: 'options',
typeOptions: {
loadOptionsMethod: 'getWebinars',
},
required: true,
default: [],
description: 'Key of the webinar to which the session belongs.',
displayOptions: {
show: {
resource: [
'session',
],
operation: [
'get',
'getDetails',
],
},
},
},
{
displayName: 'Session Key',
name: 'sessionKey',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'session',
],
operation: [
'get',
'getDetails',
],
},
},
},
// ----------------------------------
// session: getDetails
// ----------------------------------
{
displayName: 'Details',
name: 'details',
type: 'options',
default: 'performance',
options: [
{
name: 'Performance',
value: 'performance',
description: 'Performance details for a webinar session.',
},
{
name: 'Polls',
value: 'polls',
description: 'Questions and answers for polls from a webinar session.',
},
{
name: 'Questions',
value: 'questions',
description: 'Questions and answers for a past webinar session.',
},
{
name: 'Surveys',
value: 'surveys',
description: 'Surveys for a past webinar session.',
},
],
displayOptions: {
show: {
resource: [
'session',
],
operation: [
'getDetails',
],
},
},
},
] as INodeProperties[];

View file

@ -0,0 +1,543 @@
import {
INodeProperties,
} from 'n8n-workflow';
export const webinarOperations = [
{
displayName: 'Operation',
name: 'operation',
type: 'options',
default: 'get',
description: 'Operation to perform',
options: [
{
name: 'Create',
value: 'create',
},
// {
// name: 'Delete',
// value: 'delete',
// },
{
name: 'Get',
value: 'get',
},
{
name: 'Get All',
value: 'getAll',
},
{
name: 'Update',
value: 'update',
},
],
displayOptions: {
show: {
resource: [
'webinar',
],
},
},
},
] as INodeProperties[];
export const webinarFields = [
// ----------------------------------
// webinar: create
// ----------------------------------
{
displayName: 'Subject',
name: 'subject',
type: 'string',
required: true,
default: '',
displayOptions: {
show: {
resource: [
'webinar',
],
operation: [
'create',
],
},
},
},
{
displayName: 'Time Range',
name: 'times',
type: 'fixedCollection',
required: true,
placeholder: 'Add Time Range',
typeOptions: {
multipleValues: true,
},
default: {},
displayOptions: {
show: {
resource: [
'webinar',
],
operation: [
'create',
],
},
},
options: [
{
displayName: 'Times Properties',
name: 'timesProperties',
values: [
{
displayName: 'Start Time',
name: 'startTime',
type: 'dateTime',
required: true,
default: '',
},
{
displayName: 'End Time',
name: 'endTime',
type: 'dateTime',
required: true,
default: '',
},
],
},
],
},
{
displayName: 'Additional Fields',
name: 'additionalFields',
type: 'collection',
placeholder: 'Add Field',
displayOptions: {
show: {
resource: [
'webinar',
],
operation: [
'create',
],
},
},
default: {},
options: [
{
displayName: 'Description',
name: 'description',
type: 'string',
default: '',
typeOptions: {
alwaysOpenEditWindow: true,
},
},
{
displayName: 'Experience Type',
name: 'experienceType',
type: 'options',
default: 'CLASSIC',
options: [
{
name: 'Classic',
value: 'CLASSIC',
},
{
name: 'Broadcast',
value: 'BROADCAST',
},
{
name: 'Simulive',
value: 'SIMULIVE',
},
],
},
{
displayName: 'Is On-Demand',
name: 'isOnDemand',
type: 'boolean',
default: false,
},
{
displayName: 'Is Password Protected',
name: 'isPasswordProtected',
type: 'boolean',
default: false,
},
{
displayName: 'Timezone',
name: 'timezone',
type: 'options',
required: true,
default: '',
placeholder: '2020-12-11T09:00:00Z',
typeOptions: {
alwaysOpenEditWindow: true,
loadOptionsMethod: 'getTimezones',
},
},
{
displayName: 'Webinar Type',
name: 'type',
type: 'options',
default: 'single_session',
options: [
{
name: 'Single Session',
value: 'single_session',
description: 'Webinar with one single meeting.',
},
{
name: 'Series',
value: 'series',
description: 'Webinar with multiple meetings times where attendees choose only one to attend.',
},
{
name: 'Sequence',
value: 'sequence',
description: 'Webinar with multiple meeting times where attendees are expected to be the same for all sessions.',
},
],
},
],
},
// ----------------------------------
// webinar: delete
// ----------------------------------
{
displayName: 'Webinar Key',
name: 'webinarKey',
type: 'string',
required: true,
default: '',
description: 'Key of the webinar to delete.',
displayOptions: {
show: {
resource: [
'webinar',
],
operation: [
'delete',
],
},
},
},
{
displayName: 'Additional Fields',
name: 'additionalFields',
type: 'collection',
placeholder: 'Add Field',
displayOptions: {
show: {
resource: [
'webinar',
],
operation: [
'delete',
],
},
},
default: {},
options: [
{
displayName: 'Send Cancellation E-mails',
name: 'sendCancellationEmails',
type: 'boolean',
default: false,
},
],
},
// ----------------------------------
// webinar: get
// ----------------------------------
{
displayName: 'Webinar Key',
name: 'webinarKey',
type: 'string',
required: true,
default: '',
description: 'Key of the webinar to retrieve.',
displayOptions: {
show: {
resource: [
'webinar',
],
operation: [
'get',
],
},
},
},
// ----------------------------------
// webinar: getAll
// ----------------------------------
{
displayName: 'Return All',
name: 'returnAll',
type: 'boolean',
default: false,
description: 'Return all results.',
displayOptions: {
show: {
resource: [
'webinar',
],
operation: [
'getAll',
],
},
},
},
{
displayName: 'Limit',
name: 'limit',
type: 'number',
default: 10,
description: 'The number of results to return.',
typeOptions: {
minValue: 1,
maxValue: 100,
},
displayOptions: {
show: {
resource: [
'webinar',
],
operation: [
'getAll',
],
returnAll: [
false,
],
},
},
},
{
displayName: 'Additional Fields',
name: 'additionalFields',
type: 'collection',
placeholder: 'Add Field',
displayOptions: {
show: {
resource: [
'webinar',
],
operation: [
'getAll',
],
},
},
default: {},
options: [
{
displayName: 'Time Range',
name: 'times',
type: 'fixedCollection',
placeholder: 'Add Time Range',
required: true,
default: {},
options: [
{
displayName: 'Times Properties',
name: 'timesProperties',
values: [
{
displayName: 'Start Time',
name: 'fromTime',
type: 'dateTime',
description: 'Start of the datetime range for the webinar.',
default: '',
},
{
displayName: 'End Time',
name: 'toTime',
type: 'dateTime',
description: 'End of the datetime range for the webinar.',
default: '',
},
],
},
],
},
],
},
// ----------------------------------
// webinar: update
// ----------------------------------
{
displayName: 'Webinar Key',
name: 'webinarKey',
type: 'string',
required: true,
default: '',
description: 'Key of the webinar to update.',
displayOptions: {
show: {
resource: [
'webinar',
],
operation: [
'update',
],
},
},
},
{
displayName: 'Notify Participants',
name: 'notifyParticipants',
type: 'boolean',
required: true,
default: false,
displayOptions: {
show: {
resource: [
'webinar',
],
operation: [
'update',
],
},
},
},
{
displayName: 'Update Fields',
name: 'updateFields',
type: 'collection',
placeholder: 'Add Field',
displayOptions: {
show: {
resource: [
'webinar',
],
operation: [
'update',
],
},
},
default: {},
options: [
{
displayName: 'Description',
name: 'description',
type: 'string',
default: '',
typeOptions: {
alwaysOpenEditWindow: true,
},
},
{
displayName: 'Experience Type',
name: 'experienceType',
type: 'options',
default: 'CLASSIC',
options: [
{
name: 'Classic',
value: 'CLASSIC',
},
{
name: 'Broadcast',
value: 'BROADCAST',
},
{
name: 'Simulive',
value: 'SIMULIVE',
},
],
},
{
displayName: 'Is On-Demand',
name: 'isOnDemand',
type: 'boolean',
default: false,
description: 'Whether the webinar may be watched anytime.',
},
{
displayName: 'Is Password Protected',
name: 'isPasswordProtected',
type: 'boolean',
default: false,
description: 'Whether the webinar requires a password for attendees to join.',
},
{
displayName: 'Times',
name: 'times',
type: 'fixedCollection',
typeOptions: {
multipleValues: true,
},
options: [
{
displayName: 'Times Properties',
name: 'timesProperties',
values: [
{
displayName: 'Start Time',
name: 'startTime',
type: 'dateTime',
required: true,
default: '',
},
{
displayName: 'End Time',
name: 'endTime',
type: 'dateTime',
required: true,
default: '',
},
],
},
],
},
{
displayName: 'Subject',
name: 'subject',
type: 'string',
default: '',
description: 'Name or topic of the webinar.',
typeOptions: {
alwaysOpenEditWindow: true,
},
},
{
displayName: 'Timezone',
name: 'timezone',
type: 'options',
required: true,
default: '',
placeholder: '2020-12-11T09:00:00Z',
description: 'Timezone where the webinar is to take place.',
typeOptions: {
alwaysOpenEditWindow: true,
loadOptionsMethod: 'getTimezones',
},
},
{
displayName: 'Webinar Type',
name: 'type',
type: 'options',
default: 'single_session',
options: [
{
name: 'Single Session',
value: 'single_session',
description: 'Webinar with one single meeting.',
},
{
name: 'Series',
value: 'series',
description: 'Webinar with multiple meetings times where attendees choose only one to attend.',
},
{
name: 'Sequence',
value: 'sequence',
description: 'Webinar with multiple meeting times where attendees are expected to be the same for all sessions.',
},
],
},
],
},
] as INodeProperties[];

View file

@ -0,0 +1,6 @@
export * from './AttendeeDescription';
export * from './CoorganizerDescription';
export * from './PanelistDescription';
export * from './RegistrantDescription';
export * from './SessionDescription';
export * from './WebinarDescription';

File diff suppressed because one or more lines are too long

After

Width:  |  Height:  |  Size: 62 KiB

View file

@ -103,6 +103,7 @@
"dist/credentials/GoogleTasksOAuth2Api.credentials.js", "dist/credentials/GoogleTasksOAuth2Api.credentials.js",
"dist/credentials/GoogleTranslateOAuth2Api.credentials.js", "dist/credentials/GoogleTranslateOAuth2Api.credentials.js",
"dist/credentials/GotifyApi.credentials.js", "dist/credentials/GotifyApi.credentials.js",
"dist/credentials/GoToWebinarOAuth2Api.credentials.js",
"dist/credentials/YouTubeOAuth2Api.credentials.js", "dist/credentials/YouTubeOAuth2Api.credentials.js",
"dist/credentials/GumroadApi.credentials.js", "dist/credentials/GumroadApi.credentials.js",
"dist/credentials/HarvestApi.credentials.js", "dist/credentials/HarvestApi.credentials.js",
@ -355,6 +356,7 @@
"dist/nodes/Google/Translate/GoogleTranslate.node.js", "dist/nodes/Google/Translate/GoogleTranslate.node.js",
"dist/nodes/Google/YouTube/YouTube.node.js", "dist/nodes/Google/YouTube/YouTube.node.js",
"dist/nodes/Gotify/Gotify.node.js", "dist/nodes/Gotify/Gotify.node.js",
"dist/nodes/GoToWebinar/GoToWebinar.node.js",
"dist/nodes/GraphQL/GraphQL.node.js", "dist/nodes/GraphQL/GraphQL.node.js",
"dist/nodes/Gumroad/GumroadTrigger.node.js", "dist/nodes/Gumroad/GumroadTrigger.node.js",
"dist/nodes/HackerNews/HackerNews.node.js", "dist/nodes/HackerNews/HackerNews.node.js",
@ -552,6 +554,7 @@
"typescript": "~3.9.7" "typescript": "~3.9.7"
}, },
"dependencies": { "dependencies": {
"@types/lossless-json": "^1.0.0",
"@types/promise-ftp": "^1.3.4", "@types/promise-ftp": "^1.3.4",
"@types/snowflake-sdk": "^1.5.1", "@types/snowflake-sdk": "^1.5.1",
"amqplib": "^0.6.0", "amqplib": "^0.6.0",
@ -573,6 +576,7 @@
"lodash.get": "^4.4.2", "lodash.get": "^4.4.2",
"lodash.set": "^4.3.2", "lodash.set": "^4.3.2",
"lodash.unset": "^4.5.2", "lodash.unset": "^4.5.2",
"lossless-json": "^1.0.4",
"mailparser": "^2.8.1", "mailparser": "^2.8.1",
"moment": "2.28.0", "moment": "2.28.0",
"moment-timezone": "^0.5.28", "moment-timezone": "^0.5.28",

View file

@ -17,6 +17,7 @@ export interface IOAuth2Options {
property?: string; property?: string;
tokenType?: string; tokenType?: string;
keepBearer?: boolean; keepBearer?: boolean;
tokenExpiredStatusCode?: number;
} }
export interface IConnection { export interface IConnection {