n8n-nodes-nextcloud-calendar
Version:
n8n Node für die Integration mit Nextcloud Calendar
501 lines • 26.8 kB
JavaScript
"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
__setModuleDefault(result, mod);
return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.NextcloudCalendar = void 0;
const n8n_workflow_1 = require("n8n-workflow");
const calendarActions = __importStar(require("./actions/calendar"));
const eventActions = __importStar(require("./actions/event"));
const nextcloud_1 = require("./helpers/nextcloud");
const descriptions_1 = require("./descriptions");
class NextcloudCalendar {
constructor() {
this.description = {
displayName: 'Nextcloud Calendar',
name: 'nextcloudCalendar',
icon: 'file:nextcloud-calendar.svg',
group: ['transform'],
version: 1,
subtitle: '={{$parameter["operation"] + ": " + $parameter["resource"]}}',
description: 'Verwalten Sie Ihre Kalender und Termine mit Nextcloud CalDAV',
defaults: {
name: 'Nextcloud Calendar',
},
inputs: [{ type: "main" }],
outputs: [{ type: "main" }],
credentials: [
{
name: 'nextcloudCalendarApi',
required: true,
displayName: 'Nextcloud Calendar API',
},
],
usableAsTool: true,
aiEnabled: true,
properties: [
descriptions_1.resources[0],
descriptions_1.calendarOperations[0],
descriptions_1.eventOperations[0],
...descriptions_1.calendarFields,
...descriptions_1.eventFields,
],
};
this.methods = {
loadOptions: {
async getCalendars() {
try {
const calendars = await calendarActions.getCalendars(this);
if (!calendars || calendars.length === 0) {
return [{ name: 'Keine Kalender Gefunden', value: '' }];
}
return calendars.map((calendar) => ({
name: calendar.displayName || 'Unbenannter Kalender',
value: calendar.displayName || calendar.url || '',
}));
}
catch (error) {
console.error('Fehler beim Laden der Kalender:', error);
return [{ name: 'Fehler Beim Laden Der Kalender', value: '' }];
}
},
},
listSearch: {
async getCalendars(filter) {
try {
const calendars = await calendarActions.getCalendars(this);
if (!calendars || calendars.length === 0) {
return {
results: [{ name: 'Keine Kalender Gefunden', value: '' }],
};
}
let calList = calendars;
if (filter && filter.trim().length > 0) {
const normalized = filter.toLowerCase();
calList = calList.filter(c => (c.displayName || '').toLowerCase().includes(normalized));
}
return {
results: calList.map((calendar) => ({
name: calendar.displayName,
value: calendar.displayName,
})),
};
}
catch (error) {
console.error('Fehler beim Laden der Kalender:', error);
return {
results: [{ name: 'Fehler Beim Laden Der Kalender', value: '' }],
};
}
},
},
};
}
async execute() {
const items = this.getInputData();
const returnData = [];
const resource = this.getNodeParameter('resource', 0);
const operation = this.getNodeParameter('operation', 0);
const getCalendarName = (calendarParam) => {
if (typeof calendarParam === 'string') {
return calendarParam;
}
return (calendarParam === null || calendarParam === void 0 ? void 0 : calendarParam.value) || (calendarParam === null || calendarParam === void 0 ? void 0 : calendarParam.id) || '';
};
for (let i = 0; i < items.length; i++) {
try {
if (resource === 'calendar') {
if (operation === 'create') {
const name = this.getNodeParameter('name', i);
const additionalFields = this.getNodeParameter('calendarSettings', i, {});
const calendarData = {
displayName: name,
...additionalFields,
};
const response = await calendarActions.createCalendar(this, calendarData);
returnData.push({
success: true,
operation: 'create',
resource: 'calendar',
message: 'Kalender erfolgreich erstellt',
data: response
});
}
else if (operation === 'delete') {
const calendarName = getCalendarName(this.getNodeParameter('calendarName', i));
const response = await calendarActions.deleteCalendar(this, calendarName);
returnData.push({
success: true,
operation: 'delete',
resource: 'calendar',
message: 'Kalender erfolgreich gelöscht',
data: response
});
}
else if (operation === 'getAll') {
const response = await calendarActions.getCalendars(this);
returnData.push({
success: true,
operation: 'getAll',
resource: 'calendar',
message: 'Kalender erfolgreich abgerufen',
data: { calendars: response }
});
}
}
else if (resource === 'event') {
if (operation === 'create') {
const title = this.getNodeParameter('title', i);
const start = this.getNodeParameter('start', i);
const end = this.getNodeParameter('end', i);
const calendarName = getCalendarName(this.getNodeParameter('calendarName', i));
if (new Date(end) <= new Date(start)) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Endzeit muss nach der Startzeit liegen', {
itemIndex: i,
});
}
const eventData = {
title,
start,
end,
calendarName,
description: this.getNodeParameter('description', i, ''),
location: this.getNodeParameter('location', i, ''),
};
const attendees = this.getNodeParameter('attendees', i, {});
if (attendees && attendees.attendeeFields) {
const attendeeFields = attendees.attendeeFields;
if (Array.isArray(attendeeFields) && attendeeFields.length > 0) {
eventData.attendees = attendeeFields.map(attendee => {
if (!attendee.email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(attendee.email)) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Ungültige E-Mail-Adresse: ${attendee.email}`, {
itemIndex: i,
});
}
return {
email: attendee.email,
displayName: attendee.displayName,
role: attendee.role,
rsvp: attendee.rsvp,
};
});
}
}
const sendInvitations = this.getNodeParameter('sendInvitations', i, false);
if (sendInvitations) {
eventData.sendInvitations = true;
}
const response = await eventActions.createEvent(this, eventData);
if (!response) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Termin konnte nicht erstellt werden - keine Antwort vom Server', {
itemIndex: i,
});
}
returnData.push({
success: true,
operation: 'create',
resource: 'event',
message: 'Termin erfolgreich erstellt',
data: response
});
}
else if (operation === 'delete') {
const calendarName = getCalendarName(this.getNodeParameter('calendarName', i));
const eventId = this.getNodeParameter('eventId', i);
const response = await eventActions.deleteEvent(this, calendarName, eventId);
if (!response || !response.success) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Termin konnte nicht gelöscht werden', {
itemIndex: i,
});
}
returnData.push({
success: true,
operation: 'delete',
resource: 'event',
message: 'Termin erfolgreich gelöscht',
data: response
});
}
else if (operation === 'get') {
const calendarName = getCalendarName(this.getNodeParameter('calendarName', i));
const eventId = this.getNodeParameter('eventId', i);
const response = await eventActions.getEvent(this, calendarName, eventId);
if (!response) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Termin konnte nicht gefunden werden', {
itemIndex: i,
});
}
returnData.push({
success: true,
operation: 'get',
resource: 'event',
message: 'Termin erfolgreich abgerufen',
data: (0, nextcloud_1.parseNextcloudResponse)(response)
});
}
else if (operation === 'getAll') {
const calendarName = getCalendarName(this.getNodeParameter('calendarName', i));
const start = this.getNodeParameter('start', i);
const end = this.getNodeParameter('end', i);
const response = await eventActions.getEvents(this, calendarName, start, end);
if (!response || !Array.isArray(response)) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Keine Termine gefunden oder ungültige Antwort vom Server', {
itemIndex: i,
});
}
const parsedEvents = response.map(event => (0, nextcloud_1.parseNextcloudResponse)(event));
returnData.push({
success: true,
operation: 'getAll',
resource: 'event',
message: 'Termine erfolgreich abgerufen',
data: { events: parsedEvents }
});
}
else if (operation === 'update') {
const updateFields = this.getNodeParameter('updateFields', i);
const calendarName = getCalendarName(this.getNodeParameter('calendarName', i));
const eventId = this.getNodeParameter('eventId', i);
if (updateFields.start && updateFields.end) {
if (new Date(updateFields.end) <= new Date(updateFields.start)) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Endzeit muss nach der Startzeit liegen', {
itemIndex: i,
});
}
}
const updateData = {
calendarName,
eventId,
title: updateFields.title,
start: updateFields.start,
end: updateFields.end,
description: updateFields.description,
location: updateFields.location,
};
const attendees = this.getNodeParameter('attendees', i, {});
if (attendees && attendees.attendeeFields) {
const attendeeFields = attendees.attendeeFields;
if (Array.isArray(attendeeFields) && attendeeFields.length > 0) {
updateData.attendees = attendeeFields.map(attendee => {
if (!attendee.email || !/^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(attendee.email)) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), `Ungültige E-Mail-Adresse: ${attendee.email}`, {
itemIndex: i,
});
}
return {
email: attendee.email,
displayName: attendee.displayName,
role: attendee.role,
rsvp: attendee.rsvp,
};
});
}
}
const sendInvitations = this.getNodeParameter('sendInvitations', i, false);
if (sendInvitations) {
updateData.sendInvitations = true;
}
const response = await eventActions.updateEvent(this, updateData);
if (!response) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Termin konnte nicht aktualisiert werden', {
itemIndex: i,
});
}
returnData.push({
success: true,
operation: 'update',
resource: 'event',
message: 'Termin erfolgreich aktualisiert',
data: (0, nextcloud_1.parseNextcloudResponse)(response)
});
}
else if (operation === 'nextEvents') {
const calendarName = getCalendarName(this.getNodeParameter('calendarName', i));
const maxEvents = this.getNodeParameter('maxEvents', i, 10);
const now = new Date();
const end = new Date();
end.setMonth(end.getMonth() + 1);
console.log(`Suche Termine in Kalender "${calendarName}" von ${now.toISOString()} bis ${end.toISOString()}`);
const response = await eventActions.getEvents(this, calendarName, now.toISOString(), end.toISOString());
if (!response) {
console.log('Keine Antwort vom Server erhalten');
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Keine Antwort vom Server', {
itemIndex: i,
});
}
console.log(`Anzahl gefundener Termine: ${Array.isArray(response) ? response.length : 0}`);
if (!Array.isArray(response) || response.length === 0) {
returnData.push({
success: true,
operation: 'nextEvents',
resource: 'event',
message: 'Keine Termine im angegebenen Zeitraum gefunden',
data: {
events: [],
message: 'Keine Termine im angegebenen Zeitraum gefunden'
}
});
}
else {
const parsedEvents = response
.slice(0, maxEvents)
.map(event => {
const parsed = (0, nextcloud_1.parseNextcloudResponse)(event);
console.log(`Verarbeite Termin: ${JSON.stringify(parsed)}`);
return parsed;
});
returnData.push({
success: true,
operation: 'nextEvents',
resource: 'event',
message: 'Termine erfolgreich abgerufen',
data: {
events: parsedEvents,
count: parsedEvents.length,
totalCount: response.length
}
});
}
}
else if (operation === 'search') {
const calendarName = getCalendarName(this.getNodeParameter('calendarName', i));
const searchTerm = this.getNodeParameter('searchTerm', i);
const start = this.getNodeParameter('start', i);
const end = this.getNodeParameter('end', i);
const searchOptions = this.getNodeParameter('searchOptions', i, {});
console.log(`Suche nach Terminen in Kalender "${calendarName}" mit Suchbegriff "${searchTerm}" im Zeitraum ${start} bis ${end}`);
const events = await eventActions.getEvents(this, calendarName, start, end);
if (!events || !Array.isArray(events)) {
throw new n8n_workflow_1.NodeOperationError(this.getNode(), 'Keine Termine gefunden oder ungültige Antwort vom Server', {
itemIndex: i,
});
}
console.log(`${events.length} Termine im angegebenen Zeitraum gefunden, filtere nach Suchbegriff`);
const filteredEvents = events.filter(event => {
const caseSensitive = !!searchOptions.caseSensitive;
const exactMatch = !!searchOptions.exactMatch;
const titlesOnly = !!searchOptions.titlesOnly;
let termToSearch = searchTerm;
if (!caseSensitive) {
termToSearch = termToSearch.toLowerCase();
}
let titleMatch = false;
if (event.title) {
let title = event.title;
if (!caseSensitive) {
title = title.toLowerCase();
}
if (exactMatch) {
titleMatch = title === termToSearch;
}
else {
titleMatch = title.includes(termToSearch);
}
}
if (titlesOnly || titleMatch) {
return titleMatch;
}
let descriptionMatch = false;
let locationMatch = false;
if (event.description) {
let description = event.description;
if (!caseSensitive) {
description = description.toLowerCase();
}
if (exactMatch) {
descriptionMatch = description === termToSearch;
}
else {
descriptionMatch = description.includes(termToSearch);
}
}
if (event.location) {
let location = event.location;
if (!caseSensitive) {
location = location.toLowerCase();
}
if (exactMatch) {
locationMatch = location === termToSearch;
}
else {
locationMatch = location.includes(termToSearch);
}
}
return titleMatch || descriptionMatch || locationMatch;
});
console.log(`${filteredEvents.length} Termine gefunden, die dem Suchbegriff entsprechen`);
if (filteredEvents.length === 0) {
returnData.push({
success: true,
operation: 'search',
resource: 'event',
message: 'Keine Termine mit dem Suchbegriff gefunden',
data: {
events: [],
searchTerm,
count: 0,
totalCount: events.length
}
});
}
else {
const parsedEvents = filteredEvents.map(event => (0, nextcloud_1.parseNextcloudResponse)(event));
returnData.push({
success: true,
operation: 'search',
resource: 'event',
message: `${filteredEvents.length} Termine gefunden`,
data: {
events: parsedEvents,
searchTerm,
count: parsedEvents.length,
totalCount: events.length
}
});
}
}
}
}
catch (error) {
if (this.continueOnFail()) {
returnData.push({
success: false,
message: error.message,
error: {
name: error.name,
description: error.description || '',
resource,
operation,
itemIndex: i,
}
});
continue;
}
throw error;
}
}
return [this.helpers.returnJsonArray(returnData)];
}
}
exports.NextcloudCalendar = NextcloudCalendar;
//# sourceMappingURL=NextcloudCalendar.node.js.map