593 lines
25 KiB
JavaScript
593 lines
25 KiB
JavaScript
"use strict";
|
|
Object.defineProperty(exports, "__esModule", { value: true });
|
|
exports.LibreBookingTrigger = void 0;
|
|
const n8n_workflow_1 = require("n8n-workflow");
|
|
/**
|
|
* Authentifizierung bei LibreBooking
|
|
*/
|
|
async function authenticateTrigger(pollFunctions, baseUrl, username, password) {
|
|
try {
|
|
const response = await pollFunctions.helpers.httpRequest({
|
|
method: 'POST',
|
|
url: `${baseUrl}/Web/Services/index.php/Authentication/Authenticate`,
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: { username, password },
|
|
json: true,
|
|
});
|
|
if (!response.isAuthenticated) {
|
|
throw new n8n_workflow_1.NodeOperationError(pollFunctions.getNode(), 'Authentifizierung fehlgeschlagen. Überprüfen Sie Ihre Zugangsdaten.');
|
|
}
|
|
return {
|
|
sessionToken: response.sessionToken,
|
|
userId: response.userId,
|
|
sessionExpires: response.sessionExpires,
|
|
};
|
|
}
|
|
catch (error) {
|
|
throw new n8n_workflow_1.NodeApiError(pollFunctions.getNode(), error, {
|
|
message: 'Authentifizierung fehlgeschlagen',
|
|
description: 'Überprüfen Sie die LibreBooking URL und Ihre Zugangsdaten.',
|
|
});
|
|
}
|
|
}
|
|
/**
|
|
* Abmeldung
|
|
*/
|
|
async function signOutTrigger(pollFunctions, baseUrl, session) {
|
|
try {
|
|
await pollFunctions.helpers.httpRequest({
|
|
method: 'POST',
|
|
url: `${baseUrl}/Web/Services/index.php/Authentication/SignOut`,
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: {
|
|
userId: session.userId,
|
|
sessionToken: session.sessionToken,
|
|
},
|
|
json: true,
|
|
});
|
|
}
|
|
catch (error) {
|
|
// Ignoriere SignOut-Fehler
|
|
}
|
|
}
|
|
/**
|
|
* Reservierungen abrufen
|
|
*/
|
|
async function getReservations(pollFunctions, baseUrl, session, startDateTime, endDateTime, filters) {
|
|
const qs = {
|
|
startDateTime,
|
|
endDateTime,
|
|
};
|
|
if (filters.resourceId)
|
|
qs.resourceId = filters.resourceId;
|
|
if (filters.scheduleId)
|
|
qs.scheduleId = filters.scheduleId;
|
|
if (filters.userId)
|
|
qs.userId = filters.userId;
|
|
try {
|
|
const response = await pollFunctions.helpers.httpRequest({
|
|
method: 'GET',
|
|
url: `${baseUrl}/Web/Services/index.php/Reservations/`,
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-Booked-SessionToken': session.sessionToken,
|
|
'X-Booked-UserId': session.userId.toString(),
|
|
},
|
|
qs,
|
|
json: true,
|
|
});
|
|
return response.reservations || [];
|
|
}
|
|
catch (error) {
|
|
throw new n8n_workflow_1.NodeApiError(pollFunctions.getNode(), error, {
|
|
message: 'Fehler beim Abrufen der Reservierungen',
|
|
});
|
|
}
|
|
}
|
|
/**
|
|
* Detaillierte Reservierungsdaten abrufen (inkl. Custom Attributes)
|
|
*/
|
|
async function getReservationDetails(pollFunctions, baseUrl, session, referenceNumber) {
|
|
try {
|
|
const response = await pollFunctions.helpers.httpRequest({
|
|
method: 'GET',
|
|
url: `${baseUrl}/Web/Services/index.php/Reservations/${referenceNumber}`,
|
|
headers: {
|
|
'Content-Type': 'application/json',
|
|
'X-Booked-SessionToken': session.sessionToken,
|
|
'X-Booked-UserId': session.userId.toString(),
|
|
},
|
|
json: true,
|
|
});
|
|
return response;
|
|
}
|
|
catch (error) {
|
|
return null;
|
|
}
|
|
}
|
|
/**
|
|
* Zeitfenster berechnen für "Get All" Mode
|
|
*/
|
|
function getTimeWindowForGetAll(customStartDate, customEndDate, defaultDays = 14) {
|
|
if (customStartDate && customEndDate) {
|
|
return {
|
|
start: new Date(customStartDate).toISOString(),
|
|
end: new Date(customEndDate).toISOString(),
|
|
};
|
|
}
|
|
const now = new Date();
|
|
const endDate = new Date(now);
|
|
endDate.setDate(endDate.getDate() + defaultDays);
|
|
return {
|
|
start: now.toISOString(),
|
|
end: endDate.toISOString(),
|
|
};
|
|
}
|
|
/**
|
|
* Zeitfenster berechnen für Polling
|
|
*/
|
|
function getTimeWindowForPolling(timeWindow) {
|
|
const now = new Date();
|
|
const start = now.toISOString();
|
|
let endDate = new Date(now);
|
|
switch (timeWindow) {
|
|
case '7days':
|
|
endDate.setDate(endDate.getDate() + 7);
|
|
break;
|
|
case '14days':
|
|
endDate.setDate(endDate.getDate() + 14);
|
|
break;
|
|
case '30days':
|
|
endDate.setDate(endDate.getDate() + 30);
|
|
break;
|
|
case '90days':
|
|
endDate.setDate(endDate.getDate() + 90);
|
|
break;
|
|
default:
|
|
endDate.setDate(endDate.getDate() + 14);
|
|
}
|
|
return {
|
|
start,
|
|
end: endDate.toISOString(),
|
|
};
|
|
}
|
|
/**
|
|
* Hash für Reservierung generieren (für Änderungserkennung)
|
|
*/
|
|
function getReservationHash(reservation) {
|
|
const relevantData = {
|
|
referenceNumber: reservation.referenceNumber,
|
|
startDate: reservation.startDate,
|
|
endDate: reservation.endDate,
|
|
title: reservation.title || '',
|
|
description: reservation.description || '',
|
|
resourceId: reservation.resourceId,
|
|
resourceName: reservation.resourceName || '',
|
|
userId: reservation.userId,
|
|
requiresApproval: reservation.requiresApproval,
|
|
participants: reservation.participants || [],
|
|
invitees: reservation.invitees || [],
|
|
};
|
|
return JSON.stringify(relevantData);
|
|
}
|
|
/**
|
|
* LibreBooking Trigger Node
|
|
*
|
|
* Drei Modi:
|
|
* 1. Get All (One-Time): Alle Reservierungen für einen Zeitraum abrufen
|
|
* 2. New Reservations (Poll): Bei neuen Reservierungen triggern
|
|
* 3. Updated Reservations (Poll): Bei geänderten Reservierungen triggern
|
|
*/
|
|
class LibreBookingTrigger {
|
|
constructor() {
|
|
this.description = {
|
|
displayName: 'LibreBooking Trigger',
|
|
name: 'libreBookingTrigger',
|
|
icon: 'file:librebooking.svg',
|
|
group: ['trigger'],
|
|
version: 1,
|
|
description: 'Wird bei neuen oder geänderten Reservierungen in LibreBooking ausgelöst',
|
|
subtitle: '={{$parameter["triggerMode"]}}',
|
|
defaults: {
|
|
name: 'LibreBooking Trigger',
|
|
},
|
|
inputs: [],
|
|
outputs: ['main'],
|
|
credentials: [
|
|
{
|
|
name: 'libreBookingApi',
|
|
required: true,
|
|
},
|
|
],
|
|
polling: true,
|
|
properties: [
|
|
// =====================================================
|
|
// TRIGGER MODE SELECTOR
|
|
// =====================================================
|
|
{
|
|
displayName: 'Trigger-Modus',
|
|
name: 'triggerMode',
|
|
type: 'options',
|
|
options: [
|
|
{
|
|
name: 'Alle Abrufen (Einmalig)',
|
|
value: 'getAll',
|
|
description: 'Alle Reservierungen für einen Zeitraum abrufen (bei jedem Poll)',
|
|
},
|
|
{
|
|
name: 'Neue Reservierungen (Polling)',
|
|
value: 'newReservations',
|
|
description: 'Nur bei neuen Reservierungen triggern',
|
|
},
|
|
{
|
|
name: 'Geänderte Reservierungen (Polling)',
|
|
value: 'updatedReservations',
|
|
description: 'Nur bei geänderten Reservierungen triggern',
|
|
},
|
|
],
|
|
default: 'getAll',
|
|
description: 'Wählen Sie den Trigger-Modus',
|
|
},
|
|
// =====================================================
|
|
// GET ALL MODE - DATE RANGE
|
|
// =====================================================
|
|
{
|
|
displayName: 'Startdatum',
|
|
name: 'startDate',
|
|
type: 'dateTime',
|
|
displayOptions: {
|
|
show: {
|
|
triggerMode: ['getAll'],
|
|
},
|
|
},
|
|
default: '',
|
|
description: 'Startdatum für den Abruf (leer = heute)',
|
|
},
|
|
{
|
|
displayName: 'Enddatum',
|
|
name: 'endDate',
|
|
type: 'dateTime',
|
|
displayOptions: {
|
|
show: {
|
|
triggerMode: ['getAll'],
|
|
},
|
|
},
|
|
default: '',
|
|
description: 'Enddatum für den Abruf (leer = 14 Tage in der Zukunft)',
|
|
},
|
|
// =====================================================
|
|
// POLLING MODE - TIME WINDOW
|
|
// =====================================================
|
|
{
|
|
displayName: 'Zeitfenster',
|
|
name: 'timeWindow',
|
|
type: 'options',
|
|
displayOptions: {
|
|
show: {
|
|
triggerMode: ['newReservations', 'updatedReservations'],
|
|
},
|
|
},
|
|
options: [
|
|
{ name: 'Nächste 7 Tage', value: '7days' },
|
|
{ name: 'Nächste 14 Tage', value: '14days' },
|
|
{ name: 'Nächste 30 Tage', value: '30days' },
|
|
{ name: 'Nächste 90 Tage', value: '90days' },
|
|
],
|
|
default: '14days',
|
|
description: 'Zeitfenster für die Überwachung von Reservierungen',
|
|
},
|
|
{
|
|
displayName: 'Hinweis',
|
|
name: 'pollingNotice',
|
|
type: 'notice',
|
|
default: '',
|
|
displayOptions: {
|
|
show: {
|
|
triggerMode: ['newReservations', 'updatedReservations'],
|
|
},
|
|
},
|
|
description: 'Beim ersten Poll werden existierende Reservierungen gespeichert, aber nicht getriggert. Nur nachfolgende Änderungen lösen den Trigger aus.',
|
|
},
|
|
// =====================================================
|
|
// FILTERS (ALL MODES)
|
|
// =====================================================
|
|
{
|
|
displayName: 'Filter',
|
|
name: 'filters',
|
|
type: 'collection',
|
|
placeholder: 'Filter hinzufügen',
|
|
default: {},
|
|
options: [
|
|
{
|
|
displayName: 'Ressourcen-ID',
|
|
name: 'resourceId',
|
|
type: 'number',
|
|
default: '',
|
|
description: 'Nur Reservierungen für diese Ressource',
|
|
},
|
|
{
|
|
displayName: 'Zeitplan-ID',
|
|
name: 'scheduleId',
|
|
type: 'number',
|
|
default: '',
|
|
description: 'Nur Reservierungen für diesen Zeitplan',
|
|
},
|
|
{
|
|
displayName: 'Benutzer-ID',
|
|
name: 'userId',
|
|
type: 'number',
|
|
default: '',
|
|
description: 'Nur Reservierungen für diesen Benutzer',
|
|
},
|
|
],
|
|
},
|
|
// =====================================================
|
|
// OPTIONS (ALL MODES)
|
|
// =====================================================
|
|
{
|
|
displayName: 'Optionen',
|
|
name: 'options',
|
|
type: 'collection',
|
|
placeholder: 'Option hinzufügen',
|
|
default: {},
|
|
options: [
|
|
{
|
|
displayName: 'Detaillierte Daten Abrufen',
|
|
name: 'fetchDetails',
|
|
type: 'boolean',
|
|
default: false,
|
|
description: 'Ruft vollständige Reservierungsdaten inkl. Custom Attributes ab (zusätzliche API-Aufrufe)',
|
|
},
|
|
{
|
|
displayName: 'Debug-Modus',
|
|
name: 'debugMode',
|
|
type: 'boolean',
|
|
default: false,
|
|
description: 'Gibt zusätzliche Debug-Informationen aus',
|
|
},
|
|
],
|
|
},
|
|
],
|
|
};
|
|
}
|
|
async poll() {
|
|
const credentials = await this.getCredentials('libreBookingApi');
|
|
const baseUrl = credentials.url.replace(/\/$/, '');
|
|
const username = credentials.username;
|
|
const password = credentials.password;
|
|
const triggerMode = this.getNodeParameter('triggerMode');
|
|
const filters = this.getNodeParameter('filters', {});
|
|
const options = this.getNodeParameter('options', {});
|
|
// Debug-Modus
|
|
const debugMode = options.debugMode || false;
|
|
const fetchDetails = options.fetchDetails || false;
|
|
// Workflow Static Data für State-Management
|
|
const webhookData = this.getWorkflowStaticData('node');
|
|
let session;
|
|
try {
|
|
session = await authenticateTrigger(this, baseUrl, username, password);
|
|
}
|
|
catch (error) {
|
|
throw error;
|
|
}
|
|
try {
|
|
const returnData = [];
|
|
// ==========================================
|
|
// MODE: Get All (One-Time / Every Poll)
|
|
// ==========================================
|
|
if (triggerMode === 'getAll') {
|
|
const startDate = this.getNodeParameter('startDate', '');
|
|
const endDate = this.getNodeParameter('endDate', '');
|
|
const { start, end } = getTimeWindowForGetAll(startDate || undefined, endDate || undefined, 14);
|
|
const reservations = await getReservations(this, baseUrl, session, start, end, filters);
|
|
if (debugMode) {
|
|
console.log(`[LibreBooking Trigger] Get All Mode - Found ${reservations.length} reservations`);
|
|
console.log(`[LibreBooking Trigger] Date Range: ${start} to ${end}`);
|
|
}
|
|
if (reservations.length === 0) {
|
|
if (debugMode) {
|
|
return [[{
|
|
json: {
|
|
_debug: true,
|
|
_message: 'Keine Reservierungen im Zeitraum gefunden',
|
|
_startDate: start,
|
|
_endDate: end,
|
|
_count: 0,
|
|
},
|
|
}]];
|
|
}
|
|
return null;
|
|
}
|
|
// Alle Reservierungen zurückgeben
|
|
for (const reservation of reservations) {
|
|
let reservationData = reservation;
|
|
if (fetchDetails) {
|
|
try {
|
|
const details = await getReservationDetails(this, baseUrl, session, reservation.referenceNumber);
|
|
if (details) {
|
|
reservationData = details;
|
|
}
|
|
}
|
|
catch (error) {
|
|
// Fallback auf Basisdaten
|
|
}
|
|
}
|
|
returnData.push({
|
|
json: {
|
|
...reservationData,
|
|
_eventType: 'getAll',
|
|
_triggeredAt: new Date().toISOString(),
|
|
},
|
|
});
|
|
}
|
|
}
|
|
// ==========================================
|
|
// MODE: New Reservations (Polling)
|
|
// ==========================================
|
|
else if (triggerMode === 'newReservations') {
|
|
const timeWindow = this.getNodeParameter('timeWindow', '14days');
|
|
const { start, end } = getTimeWindowForPolling(timeWindow);
|
|
const reservations = await getReservations(this, baseUrl, session, start, end, filters);
|
|
// Initialisiere seenIds beim ersten Poll
|
|
if (!webhookData.seenIds) {
|
|
webhookData.seenIds = [];
|
|
webhookData.isFirstPoll = true;
|
|
}
|
|
const currentIds = reservations.map((r) => r.referenceNumber);
|
|
if (debugMode) {
|
|
console.log(`[LibreBooking Trigger] New Reservations Mode`);
|
|
console.log(`[LibreBooking Trigger] First Poll: ${webhookData.isFirstPoll}`);
|
|
console.log(`[LibreBooking Trigger] Current IDs: ${currentIds.length}, Seen IDs: ${webhookData.seenIds.length}`);
|
|
}
|
|
// Beim ersten Poll: Nur IDs speichern, NICHT triggern
|
|
if (webhookData.isFirstPoll) {
|
|
webhookData.seenIds = currentIds;
|
|
webhookData.isFirstPoll = false;
|
|
webhookData.lastPollTime = new Date().toISOString();
|
|
if (debugMode) {
|
|
return [[{
|
|
json: {
|
|
_debug: true,
|
|
_message: 'Erster Poll - IDs wurden gespeichert, keine Events getriggert',
|
|
_savedIds: currentIds.length,
|
|
_ids: currentIds,
|
|
_timestamp: webhookData.lastPollTime,
|
|
},
|
|
}]];
|
|
}
|
|
return null; // Nichts triggern beim ersten Poll
|
|
}
|
|
// Nur NEUE Reservierungen (die wir noch nicht gesehen haben)
|
|
const newReservations = reservations.filter((r) => !webhookData.seenIds.includes(r.referenceNumber));
|
|
// Update seenIds mit allen aktuellen IDs
|
|
webhookData.seenIds = currentIds;
|
|
webhookData.lastPollTime = new Date().toISOString();
|
|
if (newReservations.length === 0) {
|
|
if (debugMode) {
|
|
console.log(`[LibreBooking Trigger] No new reservations found`);
|
|
}
|
|
return null;
|
|
}
|
|
// Neue Reservierungen verarbeiten
|
|
for (const reservation of newReservations) {
|
|
let reservationData = reservation;
|
|
if (fetchDetails) {
|
|
try {
|
|
const details = await getReservationDetails(this, baseUrl, session, reservation.referenceNumber);
|
|
if (details) {
|
|
reservationData = details;
|
|
}
|
|
}
|
|
catch (error) {
|
|
// Fallback auf Basisdaten
|
|
}
|
|
}
|
|
returnData.push({
|
|
json: {
|
|
...reservationData,
|
|
_eventType: 'new',
|
|
_triggeredAt: new Date().toISOString(),
|
|
},
|
|
});
|
|
}
|
|
if (debugMode && returnData.length > 0) {
|
|
console.log(`[LibreBooking Trigger] Triggering ${returnData.length} new reservations`);
|
|
}
|
|
}
|
|
// ==========================================
|
|
// MODE: Updated Reservations (Polling)
|
|
// ==========================================
|
|
else if (triggerMode === 'updatedReservations') {
|
|
const timeWindow = this.getNodeParameter('timeWindow', '14days');
|
|
const { start, end } = getTimeWindowForPolling(timeWindow);
|
|
const reservations = await getReservations(this, baseUrl, session, start, end, filters);
|
|
// Initialisiere reservationHashes beim ersten Poll
|
|
if (!webhookData.reservationHashes) {
|
|
webhookData.reservationHashes = {};
|
|
webhookData.isFirstPoll = true;
|
|
}
|
|
if (debugMode) {
|
|
console.log(`[LibreBooking Trigger] Updated Reservations Mode`);
|
|
console.log(`[LibreBooking Trigger] First Poll: ${webhookData.isFirstPoll}`);
|
|
console.log(`[LibreBooking Trigger] Current: ${reservations.length}, Stored hashes: ${Object.keys(webhookData.reservationHashes).length}`);
|
|
}
|
|
// Beim ersten Poll: Nur Hashes speichern, NICHT triggern
|
|
if (webhookData.isFirstPoll) {
|
|
for (const reservation of reservations) {
|
|
webhookData.reservationHashes[reservation.referenceNumber] = getReservationHash(reservation);
|
|
}
|
|
webhookData.isFirstPoll = false;
|
|
webhookData.lastPollTime = new Date().toISOString();
|
|
if (debugMode) {
|
|
return [[{
|
|
json: {
|
|
_debug: true,
|
|
_message: 'Erster Poll - Hashes wurden gespeichert, keine Events getriggert',
|
|
_savedHashes: Object.keys(webhookData.reservationHashes).length,
|
|
_timestamp: webhookData.lastPollTime,
|
|
},
|
|
}]];
|
|
}
|
|
return null; // Nichts triggern beim ersten Poll
|
|
}
|
|
// Geänderte Reservierungen finden
|
|
const updatedReservations = [];
|
|
const newHashes = {};
|
|
for (const reservation of reservations) {
|
|
const currentHash = getReservationHash(reservation);
|
|
const oldHash = webhookData.reservationHashes[reservation.referenceNumber];
|
|
newHashes[reservation.referenceNumber] = currentHash;
|
|
// Nur als "geändert" markieren, wenn:
|
|
// 1. Wir die Reservierung schon kennen (nicht neu)
|
|
// 2. Der Hash sich geändert hat
|
|
if (oldHash && currentHash !== oldHash) {
|
|
updatedReservations.push(reservation);
|
|
}
|
|
}
|
|
// Update Hashes mit allen aktuellen Reservierungen
|
|
webhookData.reservationHashes = newHashes;
|
|
webhookData.lastPollTime = new Date().toISOString();
|
|
if (updatedReservations.length === 0) {
|
|
if (debugMode) {
|
|
console.log(`[LibreBooking Trigger] No updated reservations found`);
|
|
}
|
|
return null;
|
|
}
|
|
// Geänderte Reservierungen verarbeiten
|
|
for (const reservation of updatedReservations) {
|
|
let reservationData = reservation;
|
|
if (fetchDetails) {
|
|
try {
|
|
const details = await getReservationDetails(this, baseUrl, session, reservation.referenceNumber);
|
|
if (details) {
|
|
reservationData = details;
|
|
}
|
|
}
|
|
catch (error) {
|
|
// Fallback auf Basisdaten
|
|
}
|
|
}
|
|
returnData.push({
|
|
json: {
|
|
...reservationData,
|
|
_eventType: 'updated',
|
|
_triggeredAt: new Date().toISOString(),
|
|
},
|
|
});
|
|
}
|
|
if (debugMode && returnData.length > 0) {
|
|
console.log(`[LibreBooking Trigger] Triggering ${returnData.length} updated reservations`);
|
|
}
|
|
}
|
|
if (returnData.length === 0) {
|
|
return null;
|
|
}
|
|
return [returnData];
|
|
}
|
|
finally {
|
|
await signOutTrigger(this, baseUrl, session);
|
|
}
|
|
}
|
|
}
|
|
exports.LibreBookingTrigger = LibreBookingTrigger;
|
|
//# sourceMappingURL=LibreBookingTrigger.node.js.map
|