✨ 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>

packages/core/src/NodeExecuteFunctions.ts

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

packages/nodes-base/credentials/GoToWebinarOAuth2Api.credentials.ts

@@ -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',
+		},
+	];
+}

packages/nodes-base/nodes/GoToWebinar/GenericFunctions.ts

@@ -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;
+	}
+}

packages/nodes-base/nodes/GoToWebinar/GoToWebinar.node.ts

@@ -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)];
+	}
+}

packages/nodes-base/nodes/GoToWebinar/descriptions/AttendeeDescription.ts

@@ -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[];

packages/nodes-base/nodes/GoToWebinar/descriptions/CoorganizerDescription.ts

@@ -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[];

packages/nodes-base/nodes/GoToWebinar/descriptions/PanelistDescription.ts

@@ -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[];

packages/nodes-base/nodes/GoToWebinar/descriptions/RegistrantDescription.ts

@@ -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[];

packages/nodes-base/nodes/GoToWebinar/descriptions/SessionDescription.ts

@@ -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[];

packages/nodes-base/nodes/GoToWebinar/descriptions/WebinarDescription.ts

@@ -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[];

packages/nodes-base/nodes/GoToWebinar/descriptions/index.ts

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

packages/nodes-base/package.json

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

packages/workflow/src/Interfaces.ts

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