992 lines
26 KiB
TypeScript
992 lines
26 KiB
TypeScript
import {
|
|
INodeType,
|
|
INodeTypeDescription,
|
|
IPollFunctions,
|
|
INodeExecutionData,
|
|
NodeApiError,
|
|
NodeOperationError,
|
|
} from 'n8n-workflow';
|
|
|
|
interface LibreBookingSession {
|
|
sessionToken: string;
|
|
userId: number;
|
|
sessionExpires: string;
|
|
}
|
|
|
|
interface ReservationData {
|
|
referenceNumber: string;
|
|
startDate: string;
|
|
endDate: string;
|
|
title: string;
|
|
resourceId: number;
|
|
userId: number;
|
|
description?: string;
|
|
resourceName?: string;
|
|
startDateTime?: string;
|
|
endDateTime?: string;
|
|
[key: string]: any;
|
|
}
|
|
|
|
interface WorkflowStaticData {
|
|
seenIds?: string[];
|
|
reservationHashes?: Record<string, string>;
|
|
isFirstPoll?: boolean;
|
|
lastPollTime?: string;
|
|
}
|
|
|
|
/**
|
|
* Authentifizierung bei LibreBooking
|
|
*/
|
|
async function authenticateTrigger(
|
|
pollFunctions: IPollFunctions,
|
|
baseUrl: string,
|
|
username: string,
|
|
password: string,
|
|
): Promise<LibreBookingSession> {
|
|
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 NodeOperationError(
|
|
pollFunctions.getNode(),
|
|
'Authentifizierung fehlgeschlagen. Überprüfen Sie Ihre Zugangsdaten.',
|
|
);
|
|
}
|
|
|
|
return {
|
|
sessionToken: response.sessionToken,
|
|
userId: response.userId,
|
|
sessionExpires: response.sessionExpires,
|
|
};
|
|
} catch (error: any) {
|
|
throw new NodeApiError(pollFunctions.getNode(), error, {
|
|
message: 'Authentifizierung fehlgeschlagen',
|
|
description: 'Überprüfen Sie die LibreBooking URL und Ihre Zugangsdaten.',
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Abmeldung
|
|
*/
|
|
async function signOutTrigger(
|
|
pollFunctions: IPollFunctions,
|
|
baseUrl: string,
|
|
session: LibreBookingSession,
|
|
): Promise<void> {
|
|
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: IPollFunctions,
|
|
baseUrl: string,
|
|
session: LibreBookingSession,
|
|
startDateTime: string,
|
|
endDateTime: string,
|
|
filters: any,
|
|
): Promise<ReservationData[]> {
|
|
const qs: any = {
|
|
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: any) {
|
|
throw new NodeApiError(pollFunctions.getNode(), error, {
|
|
message: 'Fehler beim Abrufen der Reservierungen',
|
|
});
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Detaillierte Reservierungsdaten abrufen (inkl. Custom Attributes)
|
|
*/
|
|
async function getReservationDetails(
|
|
pollFunctions: IPollFunctions,
|
|
baseUrl: string,
|
|
session: LibreBookingSession,
|
|
referenceNumber: string,
|
|
): Promise<any> {
|
|
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;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Berechnet Zeitraum basierend auf der gewählten Option
|
|
*/
|
|
function getDateRange(dateRange: string): { startDate: string; endDate: string } {
|
|
const now = new Date();
|
|
let startDate: Date;
|
|
let endDate: Date;
|
|
|
|
switch (dateRange) {
|
|
case 'thisWeek':
|
|
// Montag dieser Woche (ISO: Montag = 1, Sonntag = 0)
|
|
startDate = new Date(now);
|
|
const dayOfWeek = now.getDay();
|
|
const diffToMonday = dayOfWeek === 0 ? -6 : 1 - dayOfWeek;
|
|
startDate.setDate(now.getDate() + diffToMonday);
|
|
startDate.setHours(0, 0, 0, 0);
|
|
// Sonntag dieser Woche
|
|
endDate = new Date(startDate);
|
|
endDate.setDate(startDate.getDate() + 6);
|
|
endDate.setHours(23, 59, 59, 999);
|
|
break;
|
|
|
|
case 'next2Weeks':
|
|
startDate = new Date(now);
|
|
startDate.setHours(0, 0, 0, 0);
|
|
endDate = new Date(now);
|
|
endDate.setDate(now.getDate() + 14);
|
|
endDate.setHours(23, 59, 59, 999);
|
|
break;
|
|
|
|
case 'thisMonth':
|
|
startDate = new Date(now.getFullYear(), now.getMonth(), 1);
|
|
startDate.setHours(0, 0, 0, 0);
|
|
endDate = new Date(now.getFullYear(), now.getMonth() + 1, 0);
|
|
endDate.setHours(23, 59, 59, 999);
|
|
break;
|
|
|
|
case 'next2Months':
|
|
startDate = new Date(now);
|
|
startDate.setHours(0, 0, 0, 0);
|
|
endDate = new Date(now);
|
|
endDate.setMonth(now.getMonth() + 2);
|
|
endDate.setHours(23, 59, 59, 999);
|
|
break;
|
|
|
|
case 'thisYear':
|
|
startDate = new Date(now.getFullYear(), 0, 1);
|
|
startDate.setHours(0, 0, 0, 0);
|
|
endDate = new Date(now.getFullYear(), 11, 31);
|
|
endDate.setHours(23, 59, 59, 999);
|
|
break;
|
|
|
|
default: // custom
|
|
return { startDate: '', endDate: '' };
|
|
}
|
|
|
|
return {
|
|
startDate: startDate.toISOString(),
|
|
endDate: endDate.toISOString(),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Zeitfenster berechnen für "Get All" Mode
|
|
*/
|
|
function getTimeWindowForGetAll(
|
|
dateRange: string,
|
|
customStartDate?: string,
|
|
customEndDate?: string,
|
|
defaultDays: number = 14,
|
|
): { start: string; end: string } {
|
|
// Wenn ein vordefinierter Zeitraum gewählt wurde
|
|
if (dateRange && dateRange !== 'custom') {
|
|
const { startDate, endDate } = getDateRange(dateRange);
|
|
return { start: startDate, end: endDate };
|
|
}
|
|
|
|
// Custom Modus mit manuellen Daten
|
|
if (customStartDate && customEndDate) {
|
|
return {
|
|
start: new Date(customStartDate).toISOString(),
|
|
end: new Date(customEndDate).toISOString(),
|
|
};
|
|
}
|
|
|
|
// Fallback: Ab heute für defaultDays
|
|
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: string): { start: string; end: string } {
|
|
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;
|
|
case '180days':
|
|
endDate.setDate(endDate.getDate() + 180);
|
|
break;
|
|
default:
|
|
endDate.setDate(endDate.getDate() + 14);
|
|
}
|
|
|
|
return {
|
|
start,
|
|
end: endDate.toISOString(),
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Filter Reservierungen nach Zeitpunkt
|
|
*/
|
|
function filterByTime(reservations: ReservationData[], timeFilter: string): ReservationData[] {
|
|
if (timeFilter === 'all') {
|
|
return reservations;
|
|
}
|
|
|
|
const now = new Date();
|
|
now.setHours(0, 0, 0, 0);
|
|
|
|
return reservations.filter((reservation) => {
|
|
// Verwende startDate oder startDateTime
|
|
const dateStr = reservation.startDateTime || reservation.startDate;
|
|
if (!dateStr) return true;
|
|
|
|
const startDate = new Date(dateStr);
|
|
startDate.setHours(0, 0, 0, 0);
|
|
|
|
if (timeFilter === 'today') {
|
|
return startDate.getTime() === now.getTime();
|
|
}
|
|
|
|
if (timeFilter === 'next3Days') {
|
|
const threeDaysFromNow = new Date(now);
|
|
threeDaysFromNow.setDate(now.getDate() + 3);
|
|
return startDate >= now && startDate <= threeDaysFromNow;
|
|
}
|
|
|
|
if (timeFilter === 'next7Days') {
|
|
const sevenDaysFromNow = new Date(now);
|
|
sevenDaysFromNow.setDate(now.getDate() + 7);
|
|
return startDate >= now && startDate <= sevenDaysFromNow;
|
|
}
|
|
|
|
return true;
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Hash für Reservierung generieren (für Änderungserkennung)
|
|
*/
|
|
function getReservationHash(reservation: ReservationData): string {
|
|
const relevantData = {
|
|
referenceNumber: reservation.referenceNumber,
|
|
startDate: reservation.startDate || reservation.startDateTime,
|
|
endDate: reservation.endDate || reservation.endDateTime,
|
|
title: reservation.title || '',
|
|
description: reservation.description || '',
|
|
resourceId: reservation.resourceId,
|
|
resourceName: reservation.resourceName || '',
|
|
userId: reservation.userId,
|
|
requiresApproval: reservation.requiresApproval,
|
|
participants: reservation.participants || [],
|
|
invitees: reservation.invitees || [],
|
|
statusId: reservation.statusId,
|
|
};
|
|
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
|
|
*/
|
|
export class LibreBookingTrigger implements INodeType {
|
|
description: INodeTypeDescription = {
|
|
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 SELECTOR
|
|
// =====================================================
|
|
{
|
|
displayName: 'Zeitraum',
|
|
name: 'dateRange',
|
|
type: 'options',
|
|
displayOptions: {
|
|
show: {
|
|
triggerMode: ['getAll'],
|
|
},
|
|
},
|
|
options: [
|
|
{
|
|
name: 'Benutzerdefiniert',
|
|
value: 'custom',
|
|
description: 'Start- und Enddatum manuell angeben',
|
|
},
|
|
{
|
|
name: 'Diese Woche',
|
|
value: 'thisWeek',
|
|
description: 'Von Montag bis Sonntag der aktuellen Woche',
|
|
},
|
|
{
|
|
name: 'Nächste 2 Wochen',
|
|
value: 'next2Weeks',
|
|
description: 'Ab heute bis 14 Tage in die Zukunft',
|
|
},
|
|
{
|
|
name: 'Dieser Monat',
|
|
value: 'thisMonth',
|
|
description: 'Vom 1. bis zum letzten Tag des aktuellen Monats',
|
|
},
|
|
{
|
|
name: 'Nächste 2 Monate',
|
|
value: 'next2Months',
|
|
description: 'Ab heute bis 2 Monate in die Zukunft',
|
|
},
|
|
{
|
|
name: 'Dieses Jahr',
|
|
value: 'thisYear',
|
|
description: 'Vom 1. Januar bis 31. Dezember des aktuellen Jahres',
|
|
},
|
|
],
|
|
default: 'custom',
|
|
description: 'Vordefinierter Zeitraum für den Abruf',
|
|
},
|
|
{
|
|
displayName: 'Startdatum',
|
|
name: 'startDate',
|
|
type: 'dateTime',
|
|
displayOptions: {
|
|
show: {
|
|
triggerMode: ['getAll'],
|
|
dateRange: ['custom'],
|
|
},
|
|
},
|
|
default: '',
|
|
description: 'Startdatum für den Abruf (leer = heute)',
|
|
},
|
|
{
|
|
displayName: 'Enddatum',
|
|
name: 'endDate',
|
|
type: 'dateTime',
|
|
displayOptions: {
|
|
show: {
|
|
triggerMode: ['getAll'],
|
|
dateRange: ['custom'],
|
|
},
|
|
},
|
|
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' },
|
|
{ name: 'Nächste 180 Tage (6 Monate)', value: '180days' },
|
|
],
|
|
default: '14days',
|
|
description: 'Zeitfenster für die Überwachung von Reservierungen',
|
|
},
|
|
|
|
// =====================================================
|
|
// TIME FILTER FOR NEW/UPDATED MODES
|
|
// =====================================================
|
|
{
|
|
displayName: 'Zeit-Filter',
|
|
name: 'timeFilter',
|
|
type: 'options',
|
|
displayOptions: {
|
|
show: {
|
|
triggerMode: ['newReservations', 'updatedReservations'],
|
|
},
|
|
},
|
|
options: [
|
|
{
|
|
name: 'Alle (Kein Filter)',
|
|
value: 'all',
|
|
description: 'Alle neuen/geänderten Reservierungen, unabhängig vom Datum',
|
|
},
|
|
{
|
|
name: 'Nur Heute',
|
|
value: 'today',
|
|
description: 'Nur Reservierungen, die heute stattfinden',
|
|
},
|
|
{
|
|
name: 'Nächste 3 Tage',
|
|
value: 'next3Days',
|
|
description: 'Nur Reservierungen, die in den nächsten 3 Tagen stattfinden',
|
|
},
|
|
{
|
|
name: 'Nächste 7 Tage',
|
|
value: 'next7Days',
|
|
description: 'Nur Reservierungen, die in den nächsten 7 Tagen stattfinden',
|
|
},
|
|
],
|
|
default: 'all',
|
|
description: 'Filtert Reservierungen nach ihrem Startdatum',
|
|
},
|
|
{
|
|
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(this: IPollFunctions): Promise<INodeExecutionData[][] | null> {
|
|
const credentials = await this.getCredentials('libreBookingApi');
|
|
const baseUrl = (credentials.url as string).replace(/\/$/, '');
|
|
const username = credentials.username as string;
|
|
const password = credentials.password as string;
|
|
|
|
const triggerMode = this.getNodeParameter('triggerMode') as string;
|
|
const filters = this.getNodeParameter('filters', {}) as any;
|
|
const options = this.getNodeParameter('options', {}) as any;
|
|
|
|
// Debug-Modus
|
|
const debugMode = options.debugMode || false;
|
|
const fetchDetails = options.fetchDetails || false;
|
|
|
|
// Workflow Static Data für State-Management
|
|
const webhookData = this.getWorkflowStaticData('node') as WorkflowStaticData;
|
|
|
|
let session: LibreBookingSession;
|
|
try {
|
|
session = await authenticateTrigger(this, baseUrl, username, password);
|
|
} catch (error) {
|
|
throw error;
|
|
}
|
|
|
|
try {
|
|
const returnData: INodeExecutionData[] = [];
|
|
|
|
// ==========================================
|
|
// MODE: Get All (One-Time / Every Poll)
|
|
// ==========================================
|
|
if (triggerMode === 'getAll') {
|
|
const dateRange = this.getNodeParameter('dateRange', 'custom') as string;
|
|
const startDate = this.getNodeParameter('startDate', '') as string;
|
|
const endDate = this.getNodeParameter('endDate', '') as string;
|
|
|
|
const { start, end } = getTimeWindowForGetAll(
|
|
dateRange,
|
|
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: ${dateRange}`);
|
|
console.log(`[LibreBooking Trigger] Period: ${start} to ${end}`);
|
|
}
|
|
|
|
if (reservations.length === 0) {
|
|
if (debugMode) {
|
|
return [
|
|
[
|
|
{
|
|
json: {
|
|
_debug: true,
|
|
_message: 'Keine Reservierungen im Zeitraum gefunden',
|
|
_dateRange: dateRange,
|
|
_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',
|
|
_dateRange: dateRange,
|
|
_triggeredAt: new Date().toISOString(),
|
|
},
|
|
});
|
|
}
|
|
}
|
|
|
|
// ==========================================
|
|
// MODE: New Reservations (Polling)
|
|
// ==========================================
|
|
else if (triggerMode === 'newReservations') {
|
|
const timeWindow = this.getNodeParameter('timeWindow', '14days') as string;
|
|
const timeFilter = this.getNodeParameter('timeFilter', 'all') as string;
|
|
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: ReservationData) => r.referenceNumber);
|
|
|
|
if (debugMode) {
|
|
console.log(`[LibreBooking Trigger] New Reservations Mode`);
|
|
console.log(`[LibreBooking Trigger] First Poll: ${webhookData.isFirstPoll}`);
|
|
console.log(`[LibreBooking Trigger] Time Filter: ${timeFilter}`);
|
|
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)
|
|
let newReservations = reservations.filter(
|
|
(r: ReservationData) => !webhookData.seenIds!.includes(r.referenceNumber),
|
|
);
|
|
|
|
// Update seenIds mit allen aktuellen IDs
|
|
webhookData.seenIds = currentIds;
|
|
webhookData.lastPollTime = new Date().toISOString();
|
|
|
|
if (debugMode) {
|
|
console.log(
|
|
`[LibreBooking Trigger] Found ${newReservations.length} new reservations before filter`,
|
|
);
|
|
}
|
|
|
|
if (newReservations.length === 0) {
|
|
return null;
|
|
}
|
|
|
|
// Zeit-Filter anwenden
|
|
newReservations = filterByTime(newReservations, timeFilter);
|
|
|
|
if (debugMode) {
|
|
console.log(
|
|
`[LibreBooking Trigger] ${newReservations.length} reservations after time filter (${timeFilter})`,
|
|
);
|
|
}
|
|
|
|
if (newReservations.length === 0) {
|
|
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',
|
|
_timeFilter: timeFilter,
|
|
_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') as string;
|
|
const timeFilter = this.getNodeParameter('timeFilter', 'all') as string;
|
|
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] Time Filter: ${timeFilter}`);
|
|
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
|
|
let updatedReservations: ReservationData[] = [];
|
|
const newHashes: Record<string, string> = {};
|
|
|
|
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 (debugMode) {
|
|
console.log(
|
|
`[LibreBooking Trigger] Found ${updatedReservations.length} updated reservations before filter`,
|
|
);
|
|
}
|
|
|
|
if (updatedReservations.length === 0) {
|
|
return null;
|
|
}
|
|
|
|
// Zeit-Filter anwenden
|
|
updatedReservations = filterByTime(updatedReservations, timeFilter);
|
|
|
|
if (debugMode) {
|
|
console.log(
|
|
`[LibreBooking Trigger] ${updatedReservations.length} reservations after time filter (${timeFilter})`,
|
|
);
|
|
}
|
|
|
|
if (updatedReservations.length === 0) {
|
|
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',
|
|
_timeFilter: timeFilter,
|
|
_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);
|
|
}
|
|
}
|
|
}
|