76a236ac37
- Graceful Fallback wenn token.pickle nicht vorhanden - Warning statt Exception bei fehlenden Google Credentials - Sync wird übersprungen statt zu crashen
308 lines
12 KiB
Python
308 lines
12 KiB
Python
from services.advoware import AdvowareAPI
|
|
from config import Config
|
|
from googleapiclient.discovery import build
|
|
from google.oauth2.credentials import Credentials
|
|
from google.auth.transport.requests import Request
|
|
from google_auth_oauthlib.flow import InstalledAppFlow
|
|
import json
|
|
import datetime
|
|
import pickle
|
|
import os.path
|
|
import redis
|
|
|
|
config = {
|
|
'type': 'api',
|
|
'name': 'Advoware Calendar Sync',
|
|
'description': 'Synchronisiert Advoware Termine mit Google Calendar für alle Mitarbeiter',
|
|
'path': '/advoware/calendar/sync',
|
|
'method': 'POST',
|
|
'flows': ['advoware'],
|
|
'emits': []
|
|
}
|
|
|
|
SCOPES = ['https://www.googleapis.com/auth/calendar']
|
|
|
|
async def get_google_service():
|
|
"""Initialisiert Google Calendar API Service"""
|
|
creds = None
|
|
|
|
# Token aus Datei laden falls vorhanden
|
|
if os.path.exists('token.pickle'):
|
|
with open('token.pickle', 'rb') as token:
|
|
creds = pickle.load(token)
|
|
|
|
# Wenn keine validen Credentials, neu authentifizieren
|
|
if not creds or not creds.valid:
|
|
if creds and creds.expired and creds.refresh_token:
|
|
creds.refresh(Request())
|
|
else:
|
|
# Hier würde normalerweise der OAuth Flow laufen
|
|
# Für Server-Umgebung brauchen wir Service Account oder gespeicherte Credentials
|
|
context.logger.warning("Google OAuth Credentials nicht gefunden. Bitte token.pickle bereitstellen oder Google Calendar Sync überspringen.")
|
|
return None
|
|
|
|
# Token speichern
|
|
with open('token.pickle', 'wb') as token:
|
|
pickle.dump(creds, token)
|
|
|
|
return build('calendar', 'v3', credentials=creds)
|
|
|
|
async def get_advoware_employees(context):
|
|
"""Ruft alle Mitarbeiter von Advoware ab"""
|
|
advoware = AdvowareAPI(context)
|
|
try:
|
|
# Annahme: Mitarbeiter-Endpoint existiert ähnlich wie andere
|
|
result = await advoware.api_call('Mitarbeiter')
|
|
context.logger.info(f"Advoware Mitarbeiter abgerufen: {len(result) if isinstance(result, list) else 'unbekannt'}")
|
|
return result if isinstance(result, list) else []
|
|
except Exception as e:
|
|
context.logger.error(f"Fehler beim Abrufen der Mitarbeiter: {e}")
|
|
return []
|
|
|
|
async def ensure_google_calendar(service, employee_kuerzel, context):
|
|
"""Stellt sicher, dass ein Google Calendar für den Mitarbeiter existiert"""
|
|
calendar_name = f"AW-{employee_kuerzel}"
|
|
|
|
try:
|
|
# Bestehende Kalender prüfen
|
|
calendar_list = service.calendarList().list().execute()
|
|
for calendar in calendar_list.get('items', []):
|
|
if calendar['summary'] == calendar_name:
|
|
context.logger.info(f"Google Calendar '{calendar_name}' existiert bereits")
|
|
return calendar['id']
|
|
|
|
# Neuen Kalender erstellen
|
|
calendar_body = {
|
|
'summary': calendar_name,
|
|
'description': f'Advoware Termine für Mitarbeiter {employee_kuerzel}',
|
|
'timeZone': 'Europe/Berlin'
|
|
}
|
|
|
|
created_calendar = service.calendars().insert(body=calendar_body).execute()
|
|
calendar_id = created_calendar['id']
|
|
context.logger.info(f"Google Calendar '{calendar_name}' erstellt mit ID: {calendar_id}")
|
|
|
|
return calendar_id
|
|
|
|
except Exception as e:
|
|
context.logger.error(f"Fehler bei Google Calendar für {employee_kuerzel}: {e}")
|
|
return None
|
|
|
|
async def get_advoware_appointments(employee_kuerzel, context):
|
|
"""Ruft Termine eines Mitarbeiters aus Advoware ab"""
|
|
advoware = AdvowareAPI(context)
|
|
|
|
# Zeitraum: aktuelles Jahr + 2 Jahre
|
|
from_date = datetime.datetime.now().strftime('%Y-01-01T00:00:00Z')
|
|
to_date = (datetime.datetime.now() + datetime.timedelta(days=730)).strftime('%Y-12-31T23:59:59Z')
|
|
|
|
try:
|
|
params = {
|
|
'kuerzel': employee_kuerzel,
|
|
'from': from_date,
|
|
'to': to_date
|
|
}
|
|
result = await advoware.api_call('Termine', method='GET', params=params)
|
|
appointments = result if isinstance(result, list) else []
|
|
context.logger.info(f"Advoware Termine für {employee_kuerzel}: {len(appointments)} gefunden")
|
|
return appointments
|
|
except Exception as e:
|
|
context.logger.error(f"Fehler beim Abrufen der Termine für {employee_kuerzel}: {e}")
|
|
return []
|
|
|
|
async def get_google_events(service, calendar_id, context):
|
|
"""Ruft Events aus Google Calendar ab"""
|
|
try:
|
|
now = datetime.datetime.utcnow()
|
|
from_date = now.strftime('%Y-01-01T00:00:00Z')
|
|
to_date = (now + datetime.timedelta(days=730)).strftime('%Y-12-31T23:59:59Z')
|
|
|
|
events_result = service.events().list(
|
|
calendarId=calendar_id,
|
|
timeMin=from_date,
|
|
timeMax=to_date,
|
|
singleEvents=True,
|
|
orderBy='startTime'
|
|
).execute()
|
|
|
|
events = events_result.get('items', [])
|
|
context.logger.info(f"Google Calendar Events: {len(events)} gefunden")
|
|
return events
|
|
except Exception as e:
|
|
context.logger.error(f"Fehler beim Abrufen der Google Events: {e}")
|
|
return []
|
|
|
|
async def sync_appointment_to_google(service, calendar_id, appointment, full_content, context):
|
|
"""Synchronisiert einen Advoware-Termin zu Google Calendar"""
|
|
try:
|
|
# Start- und Endzeit aus Advoware-Daten
|
|
start_date = appointment.get('datum')
|
|
end_date = appointment.get('datumBis') or start_date
|
|
start_time = appointment.get('uhrzeitBis', '00:00:00') # Advoware hat uhrzeitBis als Endzeit?
|
|
end_time = appointment.get('uhrzeitBis', '23:59:59')
|
|
|
|
# Vollständiges Event oder nur "blocked"
|
|
if full_content:
|
|
summary = appointment.get('text', 'Advoware Termin')
|
|
description = f"Advoware Termin\nNotiz: {appointment.get('notiz', '')}\nOrt: {appointment.get('ort', '')}\nRaum: {appointment.get('raum', '')}"
|
|
location = appointment.get('ort', '')
|
|
else:
|
|
summary = "Blocked (Advoware)"
|
|
description = "Termin aus Advoware"
|
|
location = ""
|
|
|
|
event_body = {
|
|
'summary': summary,
|
|
'description': description,
|
|
'location': location,
|
|
'start': {
|
|
'dateTime': f"{start_date}T{start_time}",
|
|
'timeZone': 'Europe/Berlin',
|
|
},
|
|
'end': {
|
|
'dateTime': f"{end_date}T{end_time}",
|
|
'timeZone': 'Europe/Berlin',
|
|
},
|
|
'extendedProperties': {
|
|
'private': {
|
|
'advoware_frnr': str(appointment.get('frNr'))
|
|
}
|
|
}
|
|
}
|
|
|
|
# Event erstellen
|
|
created_event = service.events().insert(calendarId=calendar_id, body=event_body).execute()
|
|
context.logger.info(f"Termin {appointment.get('frNr')} zu Google Calendar hinzugefügt")
|
|
return created_event
|
|
|
|
except Exception as e:
|
|
context.logger.error(f"Fehler beim Sync zu Google für Termin {appointment.get('frNr')}: {e}")
|
|
return None
|
|
|
|
async def sync_event_to_advoware(service, calendar_id, event, employee_kuerzel, context):
|
|
"""Synchronisiert ein Google Event zu Advoware (falls keine frNr vorhanden)"""
|
|
try:
|
|
# Prüfen ob bereits eine frNr vorhanden
|
|
extended_props = event.get('extendedProperties', {}).get('private', {})
|
|
frnr = extended_props.get('advoware_frnr')
|
|
|
|
if frnr:
|
|
# Bereits synchronisiert
|
|
return None
|
|
|
|
# Neuen Termin in Advoware erstellen
|
|
advoware = AdvowareAPI(context)
|
|
|
|
# Start/End aus Google Event extrahieren
|
|
start = event.get('start', {}).get('dateTime', '')
|
|
end = event.get('end', {}).get('dateTime', '')
|
|
|
|
# Advoware-Termin erstellen
|
|
appointment_data = {
|
|
'text': event.get('summary', 'Google Calendar Termin'),
|
|
'notiz': event.get('description', ''),
|
|
'ort': event.get('location', ''),
|
|
'datum': start[:10] if start else datetime.datetime.now().strftime('%Y-%m-%d'),
|
|
'uhrzeitBis': start[11:19] if start else '09:00:00',
|
|
'datumBis': end[:10] if end else start[:10] if start else datetime.datetime.now().strftime('%Y-%m-%d'),
|
|
'sb': employee_kuerzel,
|
|
'anwalt': employee_kuerzel
|
|
}
|
|
|
|
result = await advoware.api_call('Termine', method='POST', json_data=appointment_data)
|
|
|
|
if result and isinstance(result, dict):
|
|
new_frnr = result.get('frNr')
|
|
if new_frnr:
|
|
# frNr zurück in Google Event schreiben
|
|
event['extendedProperties'] = event.get('extendedProperties', {})
|
|
event['extendedProperties']['private'] = event['extendedProperties'].get('private', {})
|
|
event['extendedProperties']['private']['advoware_frnr'] = str(new_frnr)
|
|
|
|
service.events().update(calendarId=calendar_id, eventId=event['id'], body=event).execute()
|
|
context.logger.info(f"Neuer Advoware Termin erstellt: {new_frnr}, frNr in Google aktualisiert")
|
|
return new_frnr
|
|
|
|
except Exception as e:
|
|
context.logger.error(f"Fehler beim Sync zu Advoware für Google Event {event.get('id')}: {e}")
|
|
return None
|
|
|
|
async def handler(req, context):
|
|
try:
|
|
# Konfiguration aus Request-Body
|
|
body = req.get('body', {})
|
|
full_content = body.get('full_content', True) # Default: volle Termindetails
|
|
|
|
context.logger.info(f"Starte Advoware Calendar Sync, full_content: {full_content}")
|
|
|
|
# Google Calendar Service initialisieren
|
|
service = await get_google_service()
|
|
if not service:
|
|
context.logger.warning("Google Calendar Service nicht verfügbar. Sync wird übersprungen.")
|
|
return {
|
|
'status': 200,
|
|
'body': {
|
|
'status': 'skipped',
|
|
'reason': 'Google Calendar credentials not configured',
|
|
'total_synced': 0
|
|
}
|
|
}
|
|
|
|
# Alle Mitarbeiter abrufen
|
|
employees = await get_advoware_employees(context)
|
|
|
|
if not employees:
|
|
return {'status': 500, 'body': {'error': 'Keine Mitarbeiter gefunden'}}
|
|
|
|
total_synced = 0
|
|
|
|
for employee in employees:
|
|
kuerzel = employee.get('kuerzel') or employee.get('anwalt')
|
|
if not kuerzel:
|
|
context.logger.warning(f"Mitarbeiter ohne Kürzel übersprungen: {employee}")
|
|
continue
|
|
|
|
context.logger.info(f"Verarbeite Mitarbeiter: {kuerzel}")
|
|
|
|
# Google Calendar sicherstellen
|
|
calendar_id = await ensure_google_calendar(service, kuerzel, context)
|
|
if not calendar_id:
|
|
continue
|
|
|
|
# Termine aus beiden Systemen abrufen
|
|
advoware_appointments = await get_advoware_appointments(kuerzel, context)
|
|
google_events = await get_google_events(service, calendar_id, context)
|
|
|
|
# Advoware → Google syncen
|
|
google_frnrs = {event.get('extendedProperties', {}).get('private', {}).get('advoware_frnr') for event in google_events}
|
|
|
|
for appointment in advoware_appointments:
|
|
frnr = str(appointment.get('frNr'))
|
|
if frnr not in google_frnrs:
|
|
await sync_appointment_to_google(service, calendar_id, appointment, full_content, context)
|
|
total_synced += 1
|
|
|
|
# Google → Advoware syncen
|
|
for event in google_events:
|
|
await sync_event_to_advoware(service, calendar_id, event, kuerzel, context)
|
|
|
|
context.logger.info(f"Advoware Calendar Sync abgeschlossen. {total_synced} Termine synchronisiert.")
|
|
|
|
return {
|
|
'status': 200,
|
|
'body': {
|
|
'status': 'completed',
|
|
'total_synced': total_synced,
|
|
'employees_processed': len([e for e in employees if e.get('kuerzel') or e.get('anwalt')])
|
|
}
|
|
}
|
|
|
|
except Exception as e:
|
|
context.logger.error(f"Fehler beim Advoware Calendar Sync: {e}")
|
|
return {
|
|
'status': 500,
|
|
'body': {
|
|
'error': 'Internal server error',
|
|
'details': str(e)
|
|
}
|
|
} |