@cryptodevops/n8n-nodes-eventbrite
Version:
Custom n8n node for Eventbrite API
786 lines (785 loc) • 35.9 kB
JavaScript
;
var __importDefault = (this && this.__importDefault) || function (mod) {
return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.Eventbrite = void 0;
const n8n_workflow_1 = require("n8n-workflow");
const axios_1 = __importDefault(require("axios"));
class Eventbrite {
constructor() {
this.description = {
displayName: 'Eventbrite',
name: 'eventbrite',
icon: 'file:eventbrite.svg',
group: ['input'],
version: 1,
subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
description: 'Interact with Eventbrite API to manage events, orders, and attendees',
defaults: {
name: 'Eventbrite',
},
inputs: ['main'],
outputs: ['main'],
usableAsTool: true,
credentials: [
{
name: 'eventbriteApi',
required: true,
},
],
requestDefaults: {
baseURL: 'https://www.eventbriteapi.com/v3',
headers: {
Accept: 'application/json',
'Content-Type': 'application/json',
},
},
properties: [
{
displayName: 'Resource',
name: 'resource',
type: 'options',
noDataExpression: true,
options: [
{
name: 'Event',
value: 'event',
},
{
name: 'Order',
value: 'order',
},
{
name: 'Organization',
value: 'organization',
},
{
name: 'User',
value: 'user',
},
{
name: 'Venue',
value: 'venue',
},
],
default: 'event',
},
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['event'],
},
},
options: [
{
name: 'Create Event',
value: 'createEvent',
description: 'Create a new event',
action: 'Create a new event',
},
{
name: 'Get Event',
value: 'getEvent',
description: 'Get details of a specific event',
action: 'Get details of a specific event',
},
{
name: 'Search Events by Organization',
value: 'searchEventsByOrg',
description: 'Search events within user organizations',
action: 'Search events within user organizations',
},
{
name: 'Update Event',
value: 'updateEvent',
description: 'Update an existing event',
action: 'Update an existing event',
},
],
default: 'getEvent',
},
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['organization'],
},
},
options: [
{
name: 'Get Organization',
value: 'getOrganization',
description: 'Get details of an organization',
action: 'Get details of an organization',
},
{
name: 'List Organization Events',
value: 'listOrgEvents',
description: 'List events for an organization',
action: 'List events for an organization',
},
],
default: 'getOrganization',
},
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['user'],
},
},
options: [
{
name: 'Get User',
value: 'getUser',
description: 'Get user details',
action: 'Get user details',
},
{
name: 'Get My Profile',
value: 'getMyProfile',
description: 'Get authenticated user profile',
action: 'Get authenticated user profile',
},
],
default: 'getMyProfile',
},
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['order'],
},
},
options: [
{
name: 'List Orders',
value: 'listOrders',
description: 'List orders for an event',
action: 'List orders for an event',
},
{
name: 'Get Order',
value: 'getOrder',
description: 'Get details of a specific order',
action: 'Get details of a specific order',
},
],
default: 'listOrders',
},
{
displayName: 'Operation',
name: 'operation',
type: 'options',
noDataExpression: true,
displayOptions: {
show: {
resource: ['venue'],
},
},
options: [
{
name: 'List Venue Events',
value: 'listVenueEvents',
description: 'List events for a specific venue',
action: 'List events for a specific venue',
},
],
default: 'listVenueEvents',
},
// Event ID Parameters
{
displayName: 'Event ID',
name: 'eventId',
type: 'string',
displayOptions: {
show: {
operation: ['getEvent', 'updateEvent', 'listOrders'],
},
},
default: '',
placeholder: '123456789',
description: 'The ID of the event',
required: true,
},
// Search Parameters
{
displayName: 'Search Query',
name: 'searchQuery',
type: 'string',
displayOptions: {
show: {
operation: ['searchEventsByOrg'],
resource: ['event'],
},
},
default: '',
placeholder: 'tech conference',
description: 'Search term to filter events by name or description',
},
{
displayName: 'Organization ID (Optional)',
name: 'searchOrgId',
type: 'string',
displayOptions: {
show: {
operation: ['searchEventsByOrg'],
resource: ['event'],
},
},
default: '',
placeholder: '123456789',
description: 'Specific organization ID to search in (leave empty to search all user organizations)',
},
// Organization ID Parameters
{
displayName: 'Organization ID',
name: 'organizationId',
type: 'string',
displayOptions: {
show: {
operation: ['getOrganization', 'listOrgEvents'],
resource: ['organization'],
},
},
default: '',
placeholder: '123456789',
description: 'The ID of the organization',
required: true,
},
// User ID Parameters
{
displayName: 'User ID',
name: 'userId',
type: 'string',
displayOptions: {
show: {
operation: ['getUser'],
resource: ['user'],
},
},
default: '',
placeholder: '123456789',
description: 'The ID of the user',
required: true,
},
// Order ID Parameters
{
displayName: 'Order ID',
name: 'orderId',
type: 'string',
displayOptions: {
show: {
operation: ['getOrder'],
resource: ['order'],
},
},
default: '',
placeholder: '123456789',
description: 'The ID of the order',
required: true,
},
// Venue ID Parameters
{
displayName: 'Venue ID',
name: 'venueId',
type: 'string',
displayOptions: {
show: {
operation: ['listVenueEvents'],
resource: ['venue'],
},
},
default: '',
placeholder: '123456789',
description: 'The ID of the venue',
required: true,
},
// Event Creation Parameters
{
displayName: 'Event Name',
name: 'eventName',
type: 'string',
displayOptions: {
show: {
operation: ['createEvent'],
resource: ['event'],
},
},
default: '',
placeholder: 'My Amazing Event',
description: 'The name of the event',
required: true,
},
{
displayName: 'Event Description',
name: 'eventDescription',
type: 'string',
typeOptions: {
rows: 4,
},
displayOptions: {
show: {
operation: ['createEvent'],
resource: ['event'],
},
},
default: '',
placeholder: 'Description of the event...',
description: 'The description of the event',
},
{
displayName: 'Start Date',
name: 'startDate',
type: 'dateTime',
displayOptions: {
show: {
operation: ['createEvent'],
resource: ['event'],
},
},
default: '',
description: 'The start date and time of the event',
required: true,
},
{
displayName: 'End Date',
name: 'endDate',
type: 'dateTime',
displayOptions: {
show: {
operation: ['createEvent'],
resource: ['event'],
},
},
default: '',
description: 'The end date and time of the event',
required: true,
},
{
displayName: 'Currency',
name: 'currency',
type: 'options',
displayOptions: {
show: {
operation: ['createEvent'],
resource: ['event'],
},
},
options: [
{
name: 'USD',
value: 'USD',
},
{
name: 'EUR',
value: 'EUR',
},
{
name: 'GBP',
value: 'GBP',
},
{
name: 'CAD',
value: 'CAD',
},
],
default: 'USD',
description: 'The currency for the event',
},
{
displayName: 'Additional Fields',
name: 'additionalFields',
type: 'collection',
placeholder: 'Add Field',
default: {},
options: [
{
displayName: 'Max Results',
name: 'maxResults',
type: 'number',
typeOptions: {
minValue: 1,
maxValue: 50,
},
default: 10,
description: 'Maximum number of results to return (1-50)',
},
{
displayName: 'AI Agent Mode',
name: 'aiMode',
type: 'boolean',
default: false,
description: 'Whether to optimize output format for AI agents (simplified and structured)',
},
{
displayName: 'Include Summary',
name: 'includeSummary',
type: 'boolean',
displayOptions: {
show: {
aiMode: [true],
},
},
default: true,
description: 'Whether to include a human-readable summary for AI agents',
},
],
},
],
};
}
async execute() {
const items = this.getInputData();
const returnData = [];
const length = items.length;
const resource = this.getNodeParameter('resource', 0);
const operation = this.getNodeParameter('operation', 0);
for (let i = 0; i < length; i++) {
try {
// Récupérer les credentials
const credentials = await this.getCredentials('eventbriteApi');
const additionalFields = this.getNodeParameter('additionalFields', i);
// Configuration de base pour axios
const axiosConfig = {
headers: {
Authorization: `Bearer ${credentials.privateToken}`,
'Content-Type': 'application/json',
},
};
let endpoint = '';
let responseData;
let params = {};
if (resource === 'event') {
if (operation === 'getEvent') {
const eventId = this.getNodeParameter('eventId', i);
endpoint = `events/${eventId}/`;
const response = await axios_1.default.get(`https://www.eventbriteapi.com/v3/${endpoint}`, axiosConfig);
responseData = response.data;
}
else if (operation === 'createEvent') {
const eventName = this.getNodeParameter('eventName', i);
const eventDescription = this.getNodeParameter('eventDescription', i);
const startDate = this.getNodeParameter('startDate', i);
const endDate = this.getNodeParameter('endDate', i);
const currency = this.getNodeParameter('currency', i);
endpoint = 'events/';
const eventData = {
event: {
name: {
html: eventName,
},
description: {
html: eventDescription,
},
start: {
timezone: 'UTC',
utc: new Date(startDate).toISOString(),
},
end: {
timezone: 'UTC',
utc: new Date(endDate).toISOString(),
},
currency: currency,
},
};
const response = await axios_1.default.post(`https://www.eventbriteapi.com/v3/${endpoint}`, eventData, axiosConfig);
responseData = response.data;
}
else if (operation === 'searchEventsByOrg') {
const searchQuery = this.getNodeParameter('searchQuery', i);
const searchOrgId = this.getNodeParameter('searchOrgId', i);
const maxResults = additionalFields.maxResults || 10;
let allEvents = [];
if (searchOrgId) {
// Search in specific organization
try {
const response = await axios_1.default.get(`https://www.eventbriteapi.com/v3/organizations/${searchOrgId}/events/`, axiosConfig);
if (response.data.events) {
allEvents = response.data.events;
}
}
catch (error) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to fetch events from organization ${searchOrgId}: ${error.message}`, {
itemIndex: i,
});
}
}
else {
// Get user organizations first, then search in all of them
try {
const orgsResponse = await axios_1.default.get('https://www.eventbriteapi.com/v3/users/me/organizations/', axiosConfig);
if (orgsResponse.data.organizations && orgsResponse.data.organizations.length > 0) {
// Fetch events from all organizations
for (const org of orgsResponse.data.organizations) {
try {
const eventsResponse = await axios_1.default.get(`https://www.eventbriteapi.com/v3/organizations/${org.id}/events/`, axiosConfig);
if (eventsResponse.data.events) {
allEvents = allEvents.concat(eventsResponse.data.events);
}
}
catch (orgError) {
// Continue with other organizations if one fails
console.warn(`Failed to fetch events from organization ${org.id}: ${orgError.message}`);
}
}
}
else {
// No organizations found, return empty result
responseData = { events: [], message: 'No organizations found for the authenticated user' };
}
}
catch (error) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Failed to fetch user organizations: ${error.message}`, {
itemIndex: i,
});
}
}
// Filter events by search query if provided
if (searchQuery && allEvents.length > 0) {
const query = searchQuery.toLowerCase();
allEvents = allEvents.filter(event => {
var _a, _b, _c, _d;
const name = (((_a = event.name) === null || _a === void 0 ? void 0 : _a.text) || ((_b = event.name) === null || _b === void 0 ? void 0 : _b.html) || '').toLowerCase();
const description = (((_c = event.description) === null || _c === void 0 ? void 0 : _c.text) || ((_d = event.description) === null || _d === void 0 ? void 0 : _d.html) || '').toLowerCase();
return name.includes(query) || description.includes(query);
});
}
// Limit results
allEvents = allEvents.slice(0, maxResults);
responseData = {
events: allEvents,
total_found: allEvents.length,
search_query: searchQuery,
organization_id: searchOrgId || 'all_user_organizations'
};
}
}
else if (resource === 'organization') {
if (operation === 'getOrganization') {
const organizationId = this.getNodeParameter('organizationId', i);
endpoint = `organizations/${organizationId}/`;
const response = await axios_1.default.get(`https://www.eventbriteapi.com/v3/${endpoint}`, axiosConfig);
responseData = response.data;
}
else if (operation === 'listOrgEvents') {
const organizationId = this.getNodeParameter('organizationId', i);
endpoint = `organizations/${organizationId}/events/`;
const response = await axios_1.default.get(`https://www.eventbriteapi.com/v3/${endpoint}`, axiosConfig);
responseData = response.data;
}
}
else if (resource === 'user') {
if (operation === 'getMyProfile') {
endpoint = 'users/me/';
const response = await axios_1.default.get(`https://www.eventbriteapi.com/v3/${endpoint}`, axiosConfig);
responseData = response.data;
}
else if (operation === 'getUser') {
const userId = this.getNodeParameter('userId', i);
endpoint = `users/${userId}/`;
const response = await axios_1.default.get(`https://www.eventbriteapi.com/v3/${endpoint}`, axiosConfig);
responseData = response.data;
}
}
else if (resource === 'order') {
if (operation === 'listOrders') {
const eventId = this.getNodeParameter('eventId', i);
endpoint = `events/${eventId}/orders/`;
const response = await axios_1.default.get(`https://www.eventbriteapi.com/v3/${endpoint}`, axiosConfig);
responseData = response.data;
}
else if (operation === 'getOrder') {
const orderId = this.getNodeParameter('orderId', i);
endpoint = `orders/${orderId}/`;
const response = await axios_1.default.get(`https://www.eventbriteapi.com/v3/${endpoint}`, axiosConfig);
responseData = response.data;
}
}
else if (resource === 'venue') {
if (operation === 'listVenueEvents') {
const venueId = this.getNodeParameter('venueId', i);
endpoint = `venues/${venueId}/events/`;
const response = await axios_1.default.get(`https://www.eventbriteapi.com/v3/${endpoint}`, axiosConfig);
responseData = response.data;
}
}
// Function to format event data
const formatEventData = (event) => {
var _a, _b, _c, _d;
const formattedEvent = {
id: event.id,
name: ((_a = event.name) === null || _a === void 0 ? void 0 : _a.text) || ((_b = event.name) === null || _b === void 0 ? void 0 : _b.html),
description: ((_c = event.description) === null || _c === void 0 ? void 0 : _c.text) || ((_d = event.description) === null || _d === void 0 ? void 0 : _d.html),
url: event.url,
start: event.start,
end: event.end,
created: event.created,
changed: event.changed,
capacity: event.capacity,
status: event.status,
currency: event.currency,
online_event: event.online_event,
organization_id: event.organization_id,
organizer_id: event.organizer_id,
venue_id: event.venue_id,
category_id: event.category_id,
subcategory_id: event.subcategory_id,
format_id: event.format_id,
resource_uri: event.resource_uri,
is_series: event.is_series,
is_free: event.is_free,
version: event.version,
summary: event.summary,
logo_id: event.logo_id,
hide_start_date: event.hide_start_date,
hide_end_date: event.hide_end_date,
locale: event.locale,
is_locked: event.is_locked,
privacy_setting: event.privacy_setting,
is_series_parent: event.is_series_parent,
inventory_type: event.inventory_type,
show_remaining: event.show_remaining,
tx_time_limit: event.tx_time_limit,
shareable: event.shareable,
invite_only: event.invite_only,
show_colors_in_seatmap_thumbnail: event.show_colors_in_seatmap_thumbnail,
};
// Add venue information if available
if (event.venue) {
formattedEvent.venue = {
id: event.venue.id,
name: event.venue.name,
address: event.venue.address,
latitude: event.venue.latitude,
longitude: event.venue.longitude,
};
}
return formattedEvent;
};
// Traiter les résultats
if (operation === 'listOrgEvents' ||
operation === 'listOrders' ||
operation === 'listVenueEvents') {
// For list operations, process the array of results
if (responseData.events || responseData.orders) {
const results = responseData.events || responseData.orders;
const maxResults = additionalFields.maxResults || 10;
const limitedResults = results.slice(0, maxResults);
for (const item of limitedResults) {
if (operation === 'listOrders') {
returnData.push({ json: item });
}
else {
returnData.push({ json: formatEventData(item) });
}
}
}
else {
returnData.push({
json: {
message: 'No results found',
operation: operation,
},
});
}
}
else {
// For single item operations, return the result directly
if (responseData) {
if (operation === 'getEvent' || operation === 'createEvent') {
returnData.push({ json: formatEventData(responseData) });
}
else {
returnData.push({ json: responseData });
}
}
else {
returnData.push({
json: {
error: 'No data found',
},
});
}
}
}
catch (error) {
if (this.continueOnFail()) {
returnData.push({
json: {
error: error.message,
},
pairedItem: {
item: i,
},
});
continue;
}
throw new n8n_workflow_1.NodeOperationError(this.getNode(), error, {
itemIndex: i,
});
}
}
// Traitement du mode AI
const aiMode = this.getNodeParameter('additionalFields.aiMode', 0, false);
if (aiMode && returnData.length > 0) {
const includeSummary = this.getNodeParameter('additionalFields.includeSummary', 0, true);
// Simplify data for AI agents
const simplifiedData = returnData
.map((item) => item.json)
.filter((item) => item.name || item.id);
// Create a summary for the AI agent
let summary = '';
if (includeSummary && simplifiedData.length > 0) {
summary = `Found ${simplifiedData.length} result(s):\n\n`;
summary += simplifiedData
.map((item, index) => {
let itemInfo = `${index + 1}. **${item.name || item.id}**\n`;
if (item.description && typeof item.description === 'string')
itemInfo += ` 📝 ${item.description.substring(0, 100)}...\n`;
if (item.start && item.start.utc)
itemInfo += ` 📅 Start: ${new Date(item.start.utc).toLocaleString()}\n`;
if (item.url)
itemInfo += ` 🔗 URL: ${item.url}\n`;
if (item.venue && item.venue.name)
itemInfo += ` 📍 Venue: ${item.venue.name}\n`;
if (item.is_free !== undefined)
itemInfo += ` 💰 ${item.is_free ? 'Free' : 'Paid'}\n`;
return itemInfo;
})
.join('\n');
}
// Return AI-optimized data
return [
[
{
json: {
ai_summary: summary,
total_results: simplifiedData.length,
results: simplifiedData,
operation: operation,
resource: resource,
timestamp: new Date().toISOString(),
},
},
],
];
}
return [returnData];
}
}
exports.Eventbrite = Eventbrite;