Seminar Gladys Assistant – API, Entwicklung und eigene Integrationen

Inhaltsübersicht

1. Einordnung und Zielsetzung
2. Lernziele
3. Seminarinhalte
4. Praxisübungen
5. Zielgruppe
6. Voraussetzungen
7. Methodik

Einordnung und Zielsetzung

Das Seminar behandelt die Entwicklung eigener Funktionen und Integrationen für Gladys Assistant. Im Mittelpunkt stehen die interne Architektur, die HTTP-API, Services, Geräte- und Ereignismodelle sowie eine reproduzierbare Entwicklungs- und Testumgebung.

Über vier Tage entsteht eine vollständige Beispielintegration: von der fachlichen Anforderung über Backend-Service und Geräteerkennung bis zur Bedienoberfläche, automatisierten Tests, Fehlerbehandlung und Paketierung für den kontrollierten Betrieb.

Lernziele

• Architektur, Datenflüsse und Erweiterungspunkte der Plattform sicher einordnen
• Eine lokale Entwicklungsumgebung reproduzierbar aufbauen und diagnostizieren
• HTTP-API, Ereignisse, Gerätefunktionen und Zustandsdaten kontrolliert verwenden
• Einen eigenen Service mit Initialisierung, Lebenszyklus und Konfiguration entwickeln
• Backend- und Frontend-Anteile verbinden und automatisiert testen
• Integrationen wartbar dokumentieren, versionieren und für Updates absichern

Seminarinhalte

1. Entwicklungsarchitektur und Quellcode-Struktur

Die Plattform wird als Zusammenspiel aus Backend, Benutzeroberfläche, Datenhaltung, Ereignisverarbeitung und Integrationsservices analysiert.

Schrittweise Bearbeitung

1. Repository-Struktur, Paketgrenzen und zentrale Startpunkte erfassen
2. Backend auf Basis von Node.js und Express sowie Frontend auf Basis von Preact zuordnen
3. Datenhaltung für Konfiguration und Zeitreihen voneinander abgrenzen
4. Lebenszyklus eines Integrationsservices vom Start bis zum kontrollierten Stopp nachvollziehen
5. Abhängigkeiten, Konfiguration und Laufzeitprotokolle in einem Architekturdiagramm dokumentieren

Arbeitsprodukt

Architekturkarte mit Komponenten, Datenflüssen und Erweiterungspunkten

2. Entwicklungsumgebung und reproduzierbarer Build

Eine lokale Umgebung wird so eingerichtet, dass Quellcodeänderungen, Tests und Fehlersuche nachvollziehbar durchgeführt werden können.

Schrittweise Bearbeitung

1. Arbeitsverzeichnis, Laufzeit, Paketverwaltung und Umgebungsvariablen vorbereiten
2. Abhängigkeiten installieren und Entwicklungsdienste kontrolliert starten
3. Backend- und Frontend-Protokolle getrennt erfassen
4. Testdaten und lokale Konfiguration von produktiven Daten trennen
5. Start-, Test- und Rücksetzablauf als wiederholbares Laborverfahren dokumentieren

Arbeitsprodukt

Funktionsfähige Entwicklungsumgebung mit Start- und Rücksetzprotokoll

3. HTTP-API, Authentifizierung und Ereignisse

Die vorhandenen Programmierschnittstellen werden für Zustandsabfragen, Befehle und Ereignisverarbeitung eingesetzt.

Schrittweise Bearbeitung

1. API-Endpunkte und erforderliche Berechtigungen systematisch inventarisieren
2. Authentifizierte Testanfragen mit ungefährlichen Laborobjekten ausführen
3. Geräte, Räume, Zustände und Szenen über die API lesen
4. Befehle mit Eingabevalidierung und eindeutiger Fehlerauswertung senden
5. Ereignisse abonnieren und asynchrone Rückmeldungen nachvollziehbar protokollieren
6. Grenzfälle wie Zeitüberschreitung, fehlendes Gerät und ungültige Nutzdaten testen

Arbeitsprodukt

API-Testkatalog mit positiven und negativen Testfällen

4. Eigener Backend-Service

Ein eigener Integrationsservice wird mit Konfiguration, Initialisierung, Geräteerkennung und sauberem Lebenszyklus umgesetzt.

Schrittweise Bearbeitung

1. Fachliche Anforderungen in Servicefunktionen und Konfigurationsfelder zerlegen
2. Servicegerüst mit Start-, Stopp- und Zustandsfunktionen anlegen
3. Konfiguration validieren und sensible Werte getrennt behandeln
4. Geräteerkennung und Zuordnung zu bestehenden Geräten implementieren
5. Befehle, Rückmeldungen und Statusänderungen über Gladys-Funktionen verarbeiten
6. Fehlerklassen, Wiederholungen und aussagekräftige Protokolle ergänzen

Arbeitsprodukt

Lauffähiger Backend-Service mit Geräteerkennung und Befehlsverarbeitung

5. Benutzeroberfläche und Konfigurationsdialog

Die Beispielintegration erhält eine verständliche Konfiguration und Statusdarstellung in der Oberfläche.

Schrittweise Bearbeitung

1. Benutzerfluss von der Aktivierung bis zur ersten Gerätezuordnung entwerfen
2. Konfigurationsansicht mit Pflichtfeldern und Validierung erstellen
3. Lade-, Erfolgs- und Fehlerzustände getrennt darstellen
4. Statusinformationen und Diagnosehinweise auf das notwendige Maß begrenzen
5. Tastaturbedienung, Beschriftungen und verständliche Fehlermeldungen prüfen
6. Frontend und Backend über klar definierte API-Aufrufe verbinden

Arbeitsprodukt

Bedienbarer Konfigurationsdialog mit Status- und Fehleranzeige

6. Tests, Qualitätssicherung und Wartbarkeit

Automatisierte Prüfungen sichern Kernfunktionen, Grenzfälle und die langfristige Pflege der Integration ab.

Schrittweise Bearbeitung

1. Unit-Tests für Konfigurationsvalidierung und Umwandlungslogik schreiben
2. Mocks für externe Geräte oder Dienste definieren
3. Integrationsprüfungen für Service-Start, Geräteerkennung und Befehle umsetzen
4. End-to-End-Ablauf für die zentrale Benutzeraktion formulieren
5. Linting, Testausführung und Fehlerberichte in einen reproduzierbaren Ablauf integrieren
6. Update-, Rückwärtskompatibilitäts- und Rückbaukonzept dokumentieren

Arbeitsprodukt

Getestete Beispielintegration mit Wartungs- und Rückbauplan

Praxisübungen

1. Eine ungefährliche Laborintegration mit mindestens einem Sensorwert und einem schaltbaren Gerät entwickeln
2. Fehlerfälle durch ungültige Konfiguration, Zeitüberschreitung und nicht erreichbares Gerät reproduzieren
3. Automatisierte Tests ausführen und einen absichtlich eingebauten Fehler lokalisieren
4. Paketierung, Dokumentation und kontrollierten Rollback der Integration erproben

Zielgruppe

Softwareentwickler, Integrationsentwickler, technische Architekten und Betreiber mit Entwicklungsverantwortung

Voraussetzungen

Sichere JavaScript- oder TypeScript-Kenntnisse, Node.js-Grundlagen, HTTP- und JSON-Verständnis, Git sowie Erfahrung mit automatisierten Tests

Methodik

Fachliche Einordnung, geführte Demonstrationen, schrittweise Laborübungen, dokumentierte Kontrollpunkte, Negativtests und strukturierte Fehleranalyse werden miteinander verbunden. Jede technische Änderung beginnt mit einer Vorprüfung und endet mit einer nachvollziehbaren Validierung.