Bachelorarbeit FAKULTÄT INFORMATIK - Martin Bilda Betreuer: M.Sc. Thomas Franzke - OPUS 4 - KOBV
←
→
Transkription von Seiteninhalten
Wenn Ihr Browser die Seite nicht korrekt rendert, bitte, lesen Sie den Inhalt der Seite unten
FAKULTÄT INFORMATIK
Bachelorarbeit
Konzeption und Anbindung eines Messenger Services
an ein CRM System
Martin Bilda
Betreuer: M.Sc. Thomas Franzke
ERKLÄRUNG ZUR BACHELORARBEIT
Bilda, Martin
Hochschule Landshut
Fakultät Informatik
Hiermit erkläre ich, dass ich die Arbeit selbständig verfasst, noch
nicht anderweitig für Prüfungszwecke vorgelegt, keine anderen als
die angegebenen Quellen oder Hilfsmittel benutzt, sowie wörtliche
und sinngemäße Zitate als solche gekennzeichnet habe.
.................... ....................................................
(Datum) (Unterschrift des Studierenden)
Abstract Im Rahmen dieser Arbeit wurde eine Anbindung eines neuen Messenger Service für Anwen- der, der CRM-Software ADITO 2020, konzipiert und implementiert. Den Ausgangspunkt liefert ein Vergleich verschiedener Messenger Services, um herauszufinden welcher Service die Anforderungen bestmöglich erfüllt. Nach der Entscheidung wurde die Lösung in den, in Java geschriebenen Unternehmenscode eingearbeitet. Diese Konzeption und Implemen- tierung ermöglicht ein noch professionelleres und effizienteres Arbeiten für die Kunden. Abschließend gewährt diese Arbeit einen Ausblick auf mögliche Erweiterungen.
Inhaltsverzeichnis
Inhaltsverzeichnis
1 Einleitung 4
1.1 Motivation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
1.2 Zielsetzung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
1.3 Aufbau der Arbeit . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2 Thematische Grundlagen 6
2.1 Begriffsdefinitionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.1 Customer Relationship Management . . . . . . . . . . . . . . 6
2.1.2 CRM-System . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.1.3 Open Authorization . . . . . . . . . . . . . . . . . . . . . . . . 7
2.2 Vorstellung des Customer Relationship Management (CRM)-Produkts
ADITO 2020 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
2.2.1 Softwarearchitektur . . . . . . . . . . . . . . . . . . . . . . . . 10
2.2.2 Software Kern und ADITO-Sytem . . . . . . . . . . . . . . . . 11
2.2.3 ADITO 2020 Designer . . . . . . . . . . . . . . . . . . . . . . . 11
3 Konzeption 13
3.1 Anforderungsanalyse . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.1.1 Nichtfunktionale Anforderungen . . . . . . . . . . . . . . . . . 13
3.1.2 Funktionale Anforderungen . . . . . . . . . . . . . . . . . . . . 14
3.2 Erläuterung der Umsetzung . . . . . . . . . . . . . . . . . . . . . . . . 17
1
Inhaltsverzeichnis
4 Messenger Service Vergleich 18
4.1 Vergleichskriterien . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.1.1 Java-Anbindung . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.1.2 Lizenz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
4.1.3 Dokumentation und Problemhilfe . . . . . . . . . . . . . . . . 19
4.1.4 Verbreitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.1.5 Aktualität . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.1.6 Features . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
4.2 Gewichtung und Punkte . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.3 Vergleich . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
4.3.1 Microsoft Teams . . . . . . . . . . . . . . . . . . . . . . . . . . 21
4.3.2 Slack . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
4.3.3 Mattermost . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4.3.4 Stackfield . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
4.4 Entscheidung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
5 Implementierung 29
5.1 Entwicklungswerkzeuge . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5.2 Verwendete Technologien . . . . . . . . . . . . . . . . . . . . . . . . . 29
5.2.1 ScribeJava . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
5.2.2 Microsoft Graph API . . . . . . . . . . . . . . . . . . . . . . . . 30
5.3 Zusammenhang zwischen ADITO, Microsoft Graph-API, Microsoft
Azure und Microsoft Teams . . . . . . . . . . . . . . . . . . . . . . . . 32
5.4 Vorbereitung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
5.5 Implementierung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
5.5.1 public class OAuth2AuthenticationProvider . . . . . . . . . . 37
5.5.2 Erzeugen eines OAuth2 Tokens . . . . . . . . . . . . . . . . . . 37
5.5.3 public class TeamsModul . . . . . . . . . . . . . . . . . . . . . 40
5.5.4 Funktion: createTeam . . . . . . . . . . . . . . . . . . . . . . . 40
5.5.5 public class JScriptTeams . . . . . . . . . . . . . . . . . . . . . 46
2
Inhaltsverzeichnis
5.6 Erstellung der Graphischen Benutzeroberfläche . . . . . . . . . . . . 47
5.6.1 Erstellung des zugehörigen Buttons "Team erstellen“ . . . . . 49
6 Fazit 51
6.1 Zusammenfassung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
6.2 Ausblick . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
Abbildungsverzeichnis 58
Tabellenverzeichnis 59
Listings 60
Glossar 61
Akronyme 64
3
1 Einleitung
1 Einleitung
1.1 Motivation
In Zeiten der agilen Softwareprogrammierung wird es immer wichtiger schnell auf
Änderungen reagieren zu können. Der Wettlauf gegen die Zeit und Konkurrenz
lässt wenig Spielraum für auf sich wartende Besprechungen mit Terminvereinba-
rung. Alle Mitarbeiter sollen möglichst ohne Verzögerung Kontakt untereinander
aufnehmen können, um relevante Themen schnellstmöglich abzuklären. Ein Mes-
senger Service (MS) ist eine schnelle, einfache und professionelle Lösung, um die
Kommunikation in einem Unternehmen sicher zu stellen. Einer der vielen Vorteile
ist zum Beispiel, dass mehreren Kollegen miteinander kommunizieren und zeit-
gleich Nachrichten senden und empfangen können. Neben dem klassischen Chat
ist es auch möglich eine Telefonkonferenz abzuhalten. Solch ein Telefongespräch
kann mit wenigen Mausklicks in eine Videokonferenz umgewandelt werden. Da-
durch können Mitarbeiter entweder selbst vor die Kamera treten oder es wird der
Bildschirm übertragen, um Anschaulichkeit in die Diskussion zu bringen. Dies sind
nur einige von vielen Gründen, weshalb immer mehr Unternehmen einen MS ver-
wenden. Jedoch findet ein stetiger Wechsel zwischen der verwendeten Software
und dem MS statt.
Dieser Medienbruch stört die Konzentration und beeinträchtigt die Performance
beim Arbeiten (vgl. “Anbindung an Microsoft Teams - Grundfunktionalität (un-
veröffentlicht)” 2020). Deshalb soll eine Anbindung für ADITO entwickelt werden,
welche es ermöglicht, aus der Unternehmenssoftware heraus, einen solchen MS zu
bedienen und verschiedenste Aktionen auszuführen.
4
1 Einleitung
1.2 Zielsetzung
Im Rahmen dieser Arbeit soll eine Anbindung an einen MS, für die CRM-Software
ADITO 2020, konzipiert und implementiert werden. Hierfür werden zuerst unter-
schiedliche MSs verglichen, um eine Übersicht über die aktuellen Softwarelösungen
der verschiedenen Hersteller zu erhalten und das bestmögliche Produkt zu finden.
Anschließend wird die Anbindung der gewählten Software implementiert.
1.3 Aufbau der Arbeit
Diese Arbeit gliedert sich in sechs Kapitel. Das erste Kapitel beschreibt Motiva-
tion und Ziel der Arbeit. Im zweiten Kapitel werden grundlegende Begriffe der
Bereiche CRM und Open Authorization (OAuth) definiert. Darüber hinaus wird
die CRM-Software ADITO 2020 vorgestellt, in der die entwickelte Anbindung ihre
Anwendung findet. Inhalt des dritten Kapitels ist eine Analyse der Anforderun-
gen an die zu entwickelnde Anbindung. Im darauffolgenden Abschnitt werden
verschiedene Vergleichskriterien gesammelt, um im Anschluss MSs anhand dieser
zu vergleichen. Als Abschluss dieses Kapitels erhält der Leser einen tabellarischen
Vergleich der in Frage kommenden MSs und eine kurz begründete Entscheidung
welcher Service gewählt wird. Kapitel Fünf zeigt die konkrete Umsetzung und
Implementierung der Arbeit, sowie die verwendeten Techniken und Werkzeuge.
Im letzten Abschnitt wird das Ergebnis der Arbeit kurz zusammengefasst und ein
Ausblick auf mögliche Erweiterungen gegeben.
52 Thematische Grundlagen
2 Thematische Grundlagen
2.1 Begriffsdefinitionen
2.1.1 Customer Relationship Management
"CRM umfaßt die Planung, Durchführung, Kontrolle sowie Anpassung aller Unter-
nehmensaktivitäten, die zu einer Erhöhung der Profitabilität der Kundenbeziehung
und damit zu einer Optimierung des Kundenportfolios beitragen"(Christian Hom-
burg/Frank Sieben 2000, S. 7).
Die wichtigsten Charakteristika des CRM sind folgende:
• Kundenorientierung
• Wirtschaftlichkeitsorientierung
• Individualisierung
• IT-Anwendung
(vgl. Christian Homburg/Frank Sieben 2000, S. 7f)
2.1.2 CRM-System
Als CRM-System bezeichnet man die Software, welche verwendet wird, um die
genannten Eigenschaften und Ziele des CRM-Ansatzes systematisch umzusetzen.
Ein CRM-System kann in drei verschiedene Bereiche eingeteilt werden. Darun-
ter zählen die operativen Instrumente. Diese unterstützen den direkten Kunden-
kontakt. Die kollaborativen Instrumente, welche die Interaktion zwischen einem
62 Thematische Grundlagen
Unternehmen und dessen Kunden betreffen und die Analytischen Instrumente,
die auf die Erfassung, Aufbereitung und anwendungsorientierte Auswertung von
Kundendaten abzielen (vgl. Prof. Dr. Heinrich Holland 2018).
2.1.3 Open Authorization
"OAuth [...] ist ein offenes Standardprotokoll, das eine sichere API-Autorisierung
ermöglicht"(IONOS 2020).
OAuth2
Die Aufgabe von OAuth2 ist es, mittels API-Autorisierung dem Nutzer mehr Flexi-
bilität bei gleichzeitig hoher Sicherheit zu ermöglichen. Des Weiteren werden keine
kryptografischen Signaturen für jede Maschine-zu-Maschine-Kommunikation im
Protokollablauf benötigt. OAuth2 wurde zusätzlich um stärker differenzierte Ge-
nehmigungsprozesse erweitert und die Performance verbessert. Zudem kann der
Anwender selbst entscheiden, welche Berechtigungen er einer Anwendung zuge-
steht (vgl. IONOS 2020).
Rollen bei OAuth2
IONOS unterscheidet in ihrem Beitrag vier Rollen:
• Resource Owner: eine Entität, die einem Client Zugriff auf seine geschützten
Daten gewährt
• Resource Server: ein Server, auf dem die geschützten Daten des Resource
Owners gespeichert sind
• Client: eine Anwendung, die auf die geschützten Daten des Resource Owners
zugreifen will
• Authorization Server: ein Server, der den Resource Owner authentifiziert
und einen zeitlich begrenzten Access-Token ausstellt
(2019)
72 Thematische Grundlagen
Genehmigungsprozesse bei OAuth2
OAuth2 besitzt vier vordefinierte Genehmigungsprozesse, die in verschiedenen
Anwendungsfällen eingesetzt werden:
• Autorisierungscode: der Client erhält durch das Einloggen am Authorization
Server einen Autorisierungscode. Im Austausch für diesen Code stellt der
Authorization Server einen Access-Token aus
• Implizite Autorisierung: der Client erhält durch das Einloggen am Authori-
zation Server direkt ein Access-Token
• Passwortfreigabe durch den Resource Owner: Benutzername und Passwort
werden dem Client übergeben, welcher sich damit am Authorization Server
authentifizieren kann
• Client-Berechtigung: durch die Registrierung einer Applikation entstehen
neue Einlogdaten, mit denen sich der Client authentifizieren kann
(vgl. IONOS 2020)
Funktionsweise von OAuth2
Nachfolgend ist ein Beispiel gegeben, wie ein solcher Protokollablauf aussehen
kann:
1. "Der Client fordert entweder direkt oder über den Authorization Server eine
Autorisierung vom Resource Owner an"
2. "Der Resource Owner erteilt eine Autorisierungsgenehmigung mittels eines
Genehmigungsprozesses"
3. "Der Client fordert mit der Autorisierungsgenehmigung einen Access-Token
vom Authorization Server an"
4. "Der Authorization Server authentifiziert den Client anhand seiner Autorisie-
rungsgenehmigung und stellt einen Access-Token aus"
82 Thematische Grundlagen
5. "Der Client benutzt den Access-Token, um die relevanten [und] geschützten
Daten des Resource Owners beim Resource Server anzufragen"
6. "Der Resource Server authentifiziert den Client anhand seines Access-Tokens
und stellt die gewünschten Daten zur Verfügung"
(IONOS 2020)
Abb. 2.1: Abstrakter OAuth2 Protokollablauf. Quelle: (IONOS 2020)
2.2 Vorstellung des CRM-Produkts ADITO 2020
ADITO 2020 ist die aktuelle Version der verwendeten CRM-Software. Die zu ent-
wickelnde Anbindung an einen MS wird dafür konzipiert und implementiert.
92 Thematische Grundlagen
2.2.1 Softwarearchitektur
In Abbildung 2.2 wird die Softwarearchitektur von ADITO dargestellt.
Grundsätzlich handelt es sich um ein Drei-Schichten-Modell. Über das Netzwerk-
protokoll TCP/IP kommunizieren die Clients mit dem Anwendungsserver (ADITO
Server). Dieser wiederum verbindet sich ebenfalls über TCP/IP auf Datenbanken,
die in der Regel auf einem eigenen Datenbank-Server liegen. Die Verbindung zwi-
schen Anwendungsserver und Datenbank wird über einen JDBC-Treiber hergestellt
(vgl. “ADITO Software GmbH: Betriebshandbuch (unveröffentlicht)” 2018, S. 10).
Abb. 2.2: ADITO 2020 Softwarearchitektur: Drei-Schichten-Modell. Quelle: (ADITO
2020)
102 Thematische Grundlagen
2.2.2 Software Kern und ADITO-Sytem
Grundsätzlich kann die Software in Software-Kern und ADITO-System unterteilt
werden. Der Kern besteht aus mehreren JAR-Dateien und stellt die Grundfunktio-
nen bereit. Dieser ist in allen ADITO Installationen, unabhängig von Größe und
Einsatzzweck des Systems, identisch. Das ADITO-System beinhaltet die Summe
an ADITO-Datenmodellen, aus welchen eine individuelle ADITO Installation be-
steht. Hier können system- und kundenspezifische Anpassungen individuell vor-
genommen werden. (vgl. “ADITO Software GmbH: Betriebshandbuch (unveröf-
fentlicht)” 2018, S. 10). Die Anbindung an einen MS wird als eigene API entwickelt.
Somit stehen im Kern die Grundfunktionalitäten zur Verfügung und können im
ADITO-System individuell für jeden Kunden angepasst werden. Daher findet die
Implementierung überwiegend im Software-Kern statt. Das ADITO-System wird
zusätzlich um eine Oberfläche, mit Hilfe des ADITO 2020 Designers, zum Bedie-
nen der Funktionen erweitert. Der Fokus dieser Arbeit liegt auf der Entwicklung
eines Konzepts, der Auswertung von Kriterien innerhalb eines Vergleichs für den
passenden Service und der Implementierung der Anbindung.
2.2.3 ADITO 2020 Designer
Der in Abbildung 2.3 dargestellte ADITO 2020 Designer ist eine Entwicklungsum-
gebung, um mit dem vorher beschriebenen ADITO-System zu arbeiten. Er dient
zur Entwicklung und Verwaltung von ADITO-Datenmodellen. Innerhalb des De-
signers wird mit der Programmiersprache JDito gearbeitet. JDito basiert auf dem
Sprachkern von JavaScript. Zusätzlich stellt JDito aditospezifische Objekte, Me-
thoden, Variablen und Konstanten zur Verfügung (vgl. “ADITO Software GmbH:
Designerhilfe (unveröffentlicht)” 2018).
112 Thematische Grundlagen
Abb. 2.3: ADITO 2020 Designer. Quelle: eigene Abbildung
123 Konzeption
3 Konzeption
3.1 Anforderungsanalyse
In diesem Abschnitt werden funktionale und nicht funktionale Anforderungen an
die Anbindung des MSs definiert und beschrieben. Abschließend wird der Umset-
zungsplan für die Anbindung auf der Grundlage dieser Anforderungen erläutert.
3.1.1 Nichtfunktionale Anforderungen
"Nichtfunktionale Anforderungen sind Anforderungen,[sic!] an die “Qualität“[,] in
welcher die geforderte Funktionalität zu erbringen ist"(R.Heini o. J.). Im Nachfol-
genden werden die drei Wichtigsten kurz erläutert.
Sicherheit
Die Anbindung eines MS hat unter Umständen zur Folge, dass vertrauliche In-
formationen abgerufen werden. Dabei muss sichergestellt sein, dass diese aus Si-
cherheitsgründen nicht gespeichert oder an Dritte weiter gegeben werden. Sollen
Daten gespeichert werden, obliegt dies dem Anwender dies zu tun. Alle nicht
verwendeten Daten werden unwiderruflich gelöscht bzw. vom Garbage Collector
vernichtet.
Benutzbarkeit
Durch die Anbindung eines MS an die ADITO-Software wird dem Anwender eine
schnelle und unkomplizierte Möglichkeit geboten den Dienst ohne Medienbruch
133 Konzeption
zu bedienen. So können Wissen und Informationen schnell geteilt und verbreitet
werden. Dies erspart den Kunden nicht nur Zeit, sondern bietet ihnen auch ein
komfortables Arbeiten mit dem Produkt.
Effizienz
Um eine angenehme Arbeitsatmosphäre innerhalb der Software zu bieten, sollte
diese die Ressourcen des Computers nicht überlasten. Bei Abfragen von Daten
werden nach Möglichkeit nur benötigte Informationen abgefragt, die zur Weiter-
verarbeitung notwendig sind. Eine Abfrage, die alle und somit auch nicht relevante
Eigenschaften eines Objekts liefert, muss im Software-Kern erst gefiltert werden,
um diese weiter zu verarbeiten. Dies benötigt Rechenaufwand und sollte daher aus
performancetechnischen Gründen vermieden werden. Aus diesem Grund wird
hier das Prinzip von Lazy Load angewendet, um so wenig Daten wie möglich
abzurufen.
3.1.2 Funktionale Anforderungen
"Funktionale Anforderungen beschreiben gewünschte Funktionalitäten [...] eines
Systems [...]"(R.Heini o. J.). Dieser Teil der Anforderungsanalyse setzt sich größten-
teils aus Kundenanforderungen, Erfahrungen aus vergangenen Kundenprojekten
und ADITO-firmeninternen Anforderungen zusammen.
Gruppenchat erstellen
Ein großer Vorteil von MSn ist es einen Gruppenchat zu benutzen, in welchem
Mitarbeiter zeitgleich über ein Thema diskutieren können. Dafür muss dieser zuerst
erstellt und Mitglieder hinzugefügt werden.
Gruppenchat einem ADITO-Projekt zuordnen
Viele Projekte in Unternehmen wachsen stetig an und erstrecken sich über mehrere
Abteilungen. In solch einer Situation ist es nicht ungewöhnlich, dass Projektmit-
143 Konzeption
glieder den Überblick über die verschiedenen Gruppenchats verlieren und somit
die Performance des Projekts in Mitleidenschaft gezogen wird. Mit Hilfe einer Zu-
ordnung der Kardinalität 1:n wird dem Problem entgegengewirkt. So existiert zu
einem Projekt genau ein Gruppenchat. Hingegen kann ein Gruppenchat auch für
mehrere Projekte relevant sein. Diese Verknüpfung ermöglicht es den Überblick zu
bewahren und in Teil- oder Unterprojekten den selben Gruppenchat zu nutzen.
Gruppenchat löschen
Wird ein Gruppenchat nicht länger benötigt, soll es möglich sein diesen aus ADI-
TO heraus zu löschen. Somit wird der Überblick gewährleistet. Ein Löschvorgang
soll im ersten Moment nicht permanent sein, um ungewollte Löschungen wieder
Rückgängig machen zu können. Deshalb wird der Gruppenchat vorerst archiviert
und erst nach Ablauf einer festgelegten Dauer unwiderruflich gelöscht.
Untergruppen erstellen
Oftmals betrifft das zu diskutierende Thema nicht alle Mitglieder eines Gruppen-
chats. Eine Lösung dafür ist es, eine Untergruppe zu erstellen und die Besprechung
dorthin zu verlagern.
Chatnachrichten in ADITO speichern
Nicht selten werden in einem Gruppenchat wichtige Informationen geteilt. Diese
sollen an einer zentralen Stelle in ADITO gespeichert werden. Durch eine Abfrage
soll eine bestimmte Anzahl von Nachrichten abgerufen werden, die dem Benutzer
in einer Tabelle aufgelistet werden. Der Anwender kann dann, wenn er das möchte,
die wichtigsten Informationen auswählen und im ADITO-System in die Datenbank
speichern.
153 Konzeption
Projektänderungen automatisch in den Gruppenchat senden
Eine Änderung am Projekt betrifft alle Mitglieder. Durch eine automatisch über-
mittelte Nachricht im verknüpften Gruppenchat sollen alle Projektmitglieder mög-
lichst schnell darüber informiert werden, welche Details sich geändert haben. Ein
großer Vorteil von MSn ist es, dass diese auch mobil verfügbar sind und abgeru-
fen werden können. Somit kann jedes Projektmitglied, unabhängig des Standortes,
über Änderungen informiert und auf dem neuesten Stand gehalten werden.
Geschickte Dokumente in ADITO speichern
Nicht nur Nachrichten, sondern auch Dokumente sind wichtige Informationen.
Für den Anwender soll es möglich sein, Dateien aus dem MS abzurufen und in
das ADITO-System hochzuladen, damit diese, wie auch die Nachrichten, an einer
zentralen Stelle in ADITO vorhanden sind.
Bestimmte Befehle als Chatnachricht sollen Aktionen in ADITO auslösen
Bespricht man in einem Gruppenchat wichtige Themen, ist es nicht vorteilhaft das
Medium zu wechseln.
Dieser Medienbruch verursacht Konzentrationsstörungen und senkt die Perfor-
mance (vgl. “Anbindung an Microsoft Teams - Grundfunktionalität (unveröffent-
licht)” 2020). Um eine bestmögliche Kundenzufriedenheit zu erreichen, soll dies
verhindert werden. Mit Hilfe einer selbst entwickelten Syntax soll dem Anwen-
der die Möglichkeit geschaffen werden bestimmte Befehle in einen Gruppenchat
zu schreiben, die Aktionen in ADITO auslösen. So muss der Benutzer nicht mehr
zwischen den Anwendungen wechseln und kann weiterhin an der Unterhaltung
teilnehmen.
163 Konzeption
3.2 Erläuterung der Umsetzung
In Kapitel 2.2.3 wird kurz auf die Programmiersprache JDito eingegangen. Wie
bereits erwähnt enthält JDito nebem dem Sprachkern von JavaScript auch adi-
tospezifische Objekte, Methoden, Variablen und Konstanten. Diese Bestandteile
werden im Software-Kern implementiert und stehen dann im ADITO Designer
zur Verfügung. Nicht alle Kunden arbeiten mit dem ausgewählten Service, daher
muss im sogenannten Customizing angepasst werden, ob die Funktionen in einer
kundenspezifischen Installation zur Verfügung stehen oder nicht. Für dieses De-
signprinzip existieren die aditospezifischen Bestandteile. Im Software-Kern wird
eine neue API entwickelt, die im ADITO Designer verwendet werden kann. Für
alle Anforderungen wird eine Funktion erstellt, welche diese so effizient und sicher
wie möglich umsetzt und mit der Oberfläche verknüpft werden kann.
174 Messenger Service Vergleich
4 Messenger Service Vergleich
Vor der Recherche wurden verschiedene Kriterien festgelegt.
Angelehnt an eine Nutzwertanalyse, wird jedem Kriterium eine Gewichtung zuge-
ordnet (vgl. Prof. Dr. Klaus Wübbenhorst u.a. 2018). Anschließend werden für jeden
MS die Kriterien kurz erläutert, bewertet und mit der Gewichtung multipliziert.
Die Summe der gewichteten Kriterien wird abschließend berechnet und für jeden
MS tabellarisch festgehalten. Am Ende werden diese miteinander verglichen und
entschieden, welcher am besten für die Anbindung geeignet ist.
4.1 Vergleichskriterien
4.1.1 Java-Anbindung
Die Java-Anbindung des MS ist eines der wichtigsten Kriterien. Damit eine Anbin-
dung an das ADITO-System möglich ist, benötigt der MS eine Schnittstelle, die es
ermöglicht, über die Programmiersprache Java, Aktionen codetechnisch auszufüh-
ren. Dies bedeutet, dass die Auswahl der MSs auf diejenigen begrenzt ist, die ein
SDK oder eine API für Java anbieten.
4.1.2 Lizenz
Die Lizenz der Schnittstelle spielt ebenfalls eine wichtige Rolle, denn der Code sollte
frei einsehbar sein, um einen genauen Überblick über Hintergrundprozesse und
Funktionen zu erhalten. Gleichzeitig sollte diese ohne Kosten kommerziell genutzt
werden können. Aus diesen Gründen werden ausschließlich MSs untersucht, deren
184 Messenger Service Vergleich
Anbindung mit einer Open Source License zur Verfügung steht.
4.1.3 Dokumentation und Problemhilfe
Eine ausführliche Dokumentation ermöglicht eine selbstständige Einarbeitung und
erleichtert die Weiterentwicklung des Projekts, unabhängig von dem eigentlichen
Entwickler. Eine möglichst große Community sorgt dafür, dass Probleme und Feh-
ler schnell gefunden und behoben werden können. Zudem gibt es vermehrt Ent-
wickler, die bei Problemen schnelle Hilfe leisten können und somit den eigenen
Entwicklungsprozess beschleunigen. Aber nicht nur die Quantität, sondern auch
die Qualität, spielt bei Dokumentationen und Problemhilfen eine Rolle. Eigene Fo-
ren der Anbieter oder Foren, in welchen Mitarbeiter des Herstellers behilflich sind,
zeichnen eine gute Problemhilfe aus.
4.1.4 Verbreitung
Die Anbindung soll den Kunden das Arbeiten mit ADITO angenehmer gestalten.
Da eine solche Schnittstelle ein neuer Meilenstein im ADITO-System ist und im
Rahmen dieser Arbeit, die erste ihrer Art entwickelt wird, ist es wichtig ein mög-
lichst großen Kundenkreis mit dieser Schnittstelle abzudecken.
4.1.5 Aktualität
Die Aktualität der Anbindung ist ein weiteres wichtiges Kriterium. Um zu ver-
hindern, dass eine Anbindung gewählt wird, die schon seit längerem nicht mehr
aktualisiert wurde oder nur sporadisch weiterentwickelt wird, werden die letzten
Updates, beziehungsweise sogenannte Commits, überprüft.
4.1.6 Features
Ein MS ist inzwischen nicht mehr nur ein Dienst, der als Chat-Programm Verwen-
dung findet. Features sind keine Notwendigkeit, aber je mehr ein Service davon
194 Messenger Service Vergleich
bietet, desto interessanter. Natürlich besteht die Devise "Quality over Quantity",
aber ein MS der neben Nachrichten kommunizieren zusätzlich Telefonie, Video-
konferenzen und Cloud-Speicher unterstützt erhält im Vergleich mehr Punkte, als
ein einfacher Messengerdienst.
4.2 Gewichtung und Punkte
Wie bereits erwähnt wird den definierten Kriterien eine Gewichtung zugeordnet.
Eine Gewichtung mit der Nummer vier entspricht essentiell, drei sehr wichtig, zwei
wichtig und eins optional. Die Punktevergabe bewegt sich auf einer Skala von eins
(sehr schlecht) bis zehn (sehr gut).
Kriterium Gewichtung
Java-Anbindung 4
Lizenz 4
Dokumentation und Problemhilfe 3
Verbreitung 2
Aktualität 3
Features 1
Tab. 4.1: Gewichtung der Vergleichskriterien
4.3 Vergleich
Im Folgenden werden mehrere MSs anhand der vorher definierten Kriterien vor-
gestellt. Um diesen Teil der Arbeit kompakt zu halten, wird nur auf bestimmte
Kriterien eingegangen. Daraufhin wird für jeden Service eine Tabelle mit allen
gewichteten Kriterien bereitgestellt. Somit werden auch die nicht erläuterten Ver-
gleichskriterien miteinbezogen.
204 Messenger Service Vergleich
4.3.1 Microsoft Teams
Java-Anbindung
Die Anbindung an Microsoft Teams (MST) erfolgt über die, ebenfalls von Microsoft
entwickelte, Microsoft Graph (MSG)-API. Diese Schnittstelle wird als Java-SDK
zur Verfügung gestellt und kann über Maven eingebunden werden (vgl. Deepak
Agrawal u.a. 2020b).
Dokumentation und Problemhilfe
Microsoft bietet eine umfangreiche Dokumentation. In den Microsoft-Docs werden
alle verfügbaren Funktionen ausführlich erklärt und meistens auch ein Beispielcode
angehängt. Dies erleichtert das Einarbeiten in die Materie. Neben der qualitativ
hochwertigen Dokumentation, gehört die Microsoft Community zu den größten der
Welt. Unzählige Foren von Microsoft selbst bieten Hilfestellung oder Problemhilfe
an und geben Auskunft über Bugs oder Updates. Das bekannteste Forum ist das
“Stackoverflow-Forum", in dem Microsoft-Mitarbeiter aktiv sind und auf Fragen
eingehen.
Aktualität
Microsoft entwickelt mit der Programmiersprache C#. Aus diesem Grund wird das
Java-SDK nicht mit vollem Ehrgeiz verfolgt. Dennoch werden meistens monatlich
neue Updates zur Verfügung gestellt (vgl. Deepak Agrawal u.a. 2020a).
Features
Neben der normalen Kommunikationsmöglichkeit von Nachrichten schreiben, bie-
tet MST eine Vielzahl von Features. Telefonie, Videokonferenz und ein gemeinsa-
mer Cloud-Speicher, den sogenannten Sharepoint-Sites, sind nur eine Teilmenge
von den zusätzlichen Funktionen von Teams. Auch man selbst kann das Arbeiten
mit Teams verbessern, indem eine eigene MST Applikation entwickelt wird, die
einfach in einen Gruppenchat installiert werden kann.
214 Messenger Service Vergleich
Zusammenfassung
Kriterium Information Gewicht · Punkte Punkte
Java-Anbindung SDK 4 · 10 40
Lizenz MIT (vgl. Deepak Agrawal 4 · 10 40
2018)
Dokumentation sehr ausführlich und qua- 3 · 10 30
und Problemhilfe litativ sehr hochwertig,
große Community
Verbreitung 20 Millionen aktive Nutzer 2 · 10 20
pro Tag (vgl. Jared Spataro
2019)
Aktualität Commits: monatlich 3·6 18
Features sehr viele 1·9 9
Summe – – 157
Tab. 4.2: Microsoft Teams Kriterien
4.3.2 Slack
Java-Anbindung
Auch Slack bietet als Schnittstelle ein SDK an, das von GitHub heruntergeladen
oder über Maven eingebunden werden kann (vgl. Kazuhiro Sera u.a. 2020b).
Dokumentation und Problemhilfe
Neben einer ausführlichen und qualitativ sehr guten Dokumentation, bietet Slack
selbst eine überschaubare Anzahl von Möglichkeiten, um Auskunft über Fragen
zu erhalten. Zum Einen die sogenannte Slack Community, die eine Art Forum für
Slack-Entwickler ist. Zum Anderen ein Slack-Support-Center, in welchem jedoch
vorrangig Anwendungsproblemen und keinen Entwicklungsproblemen entgegen
gewirkt wird.
224 Messenger Service Vergleich
Aktualität
Den letzten Commits zufolge, werden fast täglich Verbesserungen in den Code der
Schnittstelle eingearbeitet (vgl. Kazuhiro Sera u.a. 2020a).
Features
Audio- und Videokonferenzen oder versenden von Dokumenten sind in Slack kein
Problem. Integrierte Apps wie zum Beispiel Google-Drive, Dropbox oder Salesforce
können in Untergruppen hinzugefügt werden. Zusätzlich ist es möglich, mit einer
von Slack zur Verfügung gestellten Bibliothek namens “Bolt“, einen eigenen Slack-
Client zu entwickeln.
Zusammenfassung
Kriterium Information Gewicht · Punkte Punkte
Java-Anbindung SDK 4 · 10 40
Lizenz MIT (vgl. Kazuhiro Sera 4 · 10 40
2020)
Dokumentation ausführlich und hochwer- 3·7 21
und Problemhilfe tig, große Community
Verbreitung 12 Millionen aktive Nutzer 2·8 16
pro Tag (vgl. Brian Elliott
2019)
Aktualität Commits: fast täglich 3·9 27
Features sehr viele 1·9 9
Summe – – 153
Tab. 4.3: Slack Kriterien
234 Messenger Service Vergleich
4.3.3 Mattermost
Java-Anbindung
Wie schon die zwei Vorgänger liefert auch Mattermost ein SDK, dass man über
GitHub oder Maven in das eigene Projekt einbinden kann. Dieses stellt die Grund-
funktionalitäten zur Verfügung (vgl. Takayuki Maruyama u.a. 2020b).
Dokumentation und Problemhilfe
Mattermosts Dokumentation ist sehr umfangreich und bietet, an gleicher Stelle,
zusätzlich eine Demo-Umgebung an, in welcher die verschiedenen Befehle getestet
werden können. Neben diesen Informationen bietet Mattermost auch Videokurse
in der Mattermost-Academy an.
Aktualität
Wöchentlich werden neue Updates in den Code eingearbeitet. Allerdings lässt sich
auf der "Contributor-Seite"von GitHub entnehmen, dass an dieser Java-Schnittstelle
nur wenige Entwickler arbeiten (vgl. Takayuki Maruyama u.a. 2020a). Besteht das
Team nur aus wenigen Mitgliedern, kann dies auf lange Sicht ein Problem darstel-
len, da ein kleines Entwicklungsteam schnell aufgelöst werden kann.
Features
Mattermosts größtes Feature ist, dass es ein OpenSource-Programm ist. Das heißt
nicht nur die Java-Anbindung kann eingesehen werden, sondern der komplette
Code des MSs. Somit können Unternehmen ihren eigenen Dienst entwickeln, der
auf dem Kern von Mattermost basiert.
So entwickelte zum Beispiel Uber ein eigenes Kommunikationsprogramm namens
uChat (vgl. Oliver Voss 2018). Auch die grundsätzlichen Features, wie Sprach- und
Videoanruf oder Bildschirmübertragung sind bei Mattermost vorhanden.
244 Messenger Service Vergleich
Zusammenfassung
Kriterium Information Gewichtung · Punkte
Punkte
Java-Anbindung SDK 4 · 10 40
Lizenz Apache License 2.0 (vgl. 4·8 32
Takayuki Maruyama 2017)
Dokumentation weniger ausführlich und 3·6 18
und Problemhilfe hochwertig, eher kleine
Community
Verbreitung 600 Tausend Downloads 2 · 5 10
(vgl. Matt Asay 2019)
Aktualität Commits: fast wöchentlich 3·7 21
Features viele und OpenSource 1·9 9
Summe – – 130
Tab. 4.4: Mattermost Zusammenfassung
4.3.4 Stackfield
Java-Anbindung
Als einzige Lösung verzichtet Stackfield auf ein SDK und bietet nur eine API,
mit deren Hilfe man sogenannte Webhooks aufrufen kann. Diese müssen zuvor im
Stackfield-Client hinterlegt werden (vgl. Stackfield o. J.[c]). Ohne ein zur Verfügung
gestelltes SDK muss viel Aufwand betrieben werden, um den Anforderungen der
API gerecht zu werden, da man den Java-Code selbst programmieren muss.
Dokumentation und Problemhilfe
Stackfield selbst bietet eine Dokumentation, welche für die wenigen Funktionen
ausführliche Informationen bereitstellt.
254 Messenger Service Vergleich
Laut Unternehmenswebseite wird Stackfield von 10000 Kunden genutzt (vgl. Stack-
field o. J.[a]).
Dies ist ein kleiner Prozentsatz im Vergleich zu der Konkurrenz. Durch die geringe
Verbreitung fällt die Community klein aus. Darunter leidet auch die Problemhilfe,
da es weniger Entwickler gibt, die sich mit Stackfield beschäftigen.
Aktualität
Da es von Stackfield kein SDK gibt, in welchem neuer Code upgedatet wird,
kann über die Aktualität keine Aussage getroffen werden. Auch auf der API-
Dokumentations-Webseite befinden sich keine Angaben, ob diese auf einem ak-
tuellen Stand gehalten wird.
Features
Sicherheit steht bei Stackfield an erster Stelle. Eines der wichtigsten Features des
MSs ist, dass alle deutschen und europäischen Datenschutzrichtlinien erfüllt wer-
den. Zudem sind alle Daten verschlüsselt auf Servern in Deutschland gespeichert.
Diese Daten können selbst vom Unternehmen nicht ausgelesen werden. Neben dem
Sicherheitsaspekt fallen die sonstigen Features standardmäßig aus (vgl. Stackfield
o. J.[b]).
264 Messenger Service Vergleich
Kriterium Information Gewichtung · Punkte
Punkte
Java-Anbindung API 4·7 28
Lizenz - 4 · 10 40
Dokumentation ausführlich, sehr kleine 3·5 15
und Problemhilfe Community
Verbreitung 10000 Kunden 2·3 6
Aktualität - 3·1 3
Features viele 1·8 8
Summe – – 100
Tab. 4.5: Stackfield Zusammenfassung
274 Messenger Service Vergleich
4.4 Entscheidung
MS Zusammenfassung Punkte
Microsoft Teams + sehr große Community 157
+ sehr gute Dokumentation
+ sehr viele Kunden
Slack + große Community 153
+ gute Dokumentation
+ sehr aktuell
Mattermost + OpenSource Client 130
- kleine Community
- Apache 2.0 License
Stackfield + sehr hohe Datensicherheit 100
- kleine Community
- kein SDK
Tab. 4.6: Vergleich der MSs
Wie aus der Tabelle 4.6 ersichtlich wird, stehen MST und Slack weit vor den Alter-
nativen. MST hat den Vorteil, dass es eine größere Community und umfangreichere
Dokumentationen besitzt. Des Weiteren ist die Verbreitung von MST ein ausschlag-
gebender Punkt. Aus diesem Grund wird es gegenüber Slack bevorzugt. Somit
wird MST als MS gewählt und dafür eine Anbindung über die MSG-API und dem
MSG-Java-SDK implementiert.
285 Implementierung
5 Implementierung
5.1 Entwicklungswerkzeuge
Die Implementierung der Anbindung findet größtenteils im Software-Kern mit In-
telliJ statt. Die Anzeige und Ausführung des Web-Clients erfolgt mit Hilfe von
Google Chrome. Die Erstellung der graphischen Benutzeroberfläche wird mit dem
in Unterabschnitt 2.2.3 vorgestellten ADITO Designer vorgenommen. Um einen
ersten Einblick in die Materie zu erlangen, wird der von Microsoft zur Verfügung
gestellte Graph Explorer verwendet und mit den vordefinierten Abfragen Tests
ausgeführt. Für Testzwecke wird unter anderem auch eine erfundene Organisation
mit einer Microsoft E5 Lizenz gegründet, die es erlaubt MST zu nutzen. Mit Hil-
fe dieser Demo-Organisation können umfangreiche Szenarien abgebildet werden.
Zum Einbinden des MSG-Java-SDK wird das Managementtool Maven verwendet.
5.2 Verwendete Technologien
Im Nachfolgenden wird auf die verwendeten Technologien eingegangen, die im
Rahmen dieser Arbeit verwendet werden.
5.2.1 ScribeJava
“ScribeJava ist ein einfacher OAuth-Client für Java, der den OAuth-Fluss verwaltet.
Die Hauptfunktion der Bibliothek besteht darin, dass sie alle gängigen OAuth-APIs
der Versionen 1.0 und 2.0 unterstützt. [...] Darüber hinaus ist die Bibliothek thread-
sicher und Java7-kompatibel, sodass wir sie in älteren Umgebungen verwenden
295 Implementierung
können. [...] Der Hauptteil dieser Bibliothek ist die abstrakte Klasse OAuthService,
die alle Parameter enthält, die zur korrekten Verwaltung des OAuth-Handshakes
erforderlich sind"(Codeflow 2020).
5.2.2 Microsoft Graph API
"Microsoft Graph ist das Gateway zu Daten und Informationen in Microsoft 365. Es
bietet ein vereinheitlichtes Programmiermodell [...] Die Microsoft Graph-API bietet
einen einzelnen Endpunkt, https://graph.microsoft.com, um Zugriff auf umfangreiche,
personenbezogene Daten und Einblicke zu ermöglichen, die als Ressourcen der
Microsoft 365-Dienste bereitstehen". (Laura Graham u.a. 2020).
Abb. 5.1: Microsoft Graph. Quelle: (vgl. Laura Graham u.a. 2020)
Der soeben erwähnte Endpunkt muss für die unterschiedlichen Anfragen ange-
passt werden. Für jede Ressource existiert ein eindeutiger URL-Request, welcher
spezifische Ergebnisse liefert. Um sich zum Beispiel alle Microsoft Azure-Gruppen
liefern zu lassen, wird die API-Anfrage https://graph.microsoft.com/groups verwendet.
Ein solcher Request kann mit verschiedenen HTTP-Methoden ausgeführt werden.
Möchte man lediglich Daten abfragen, muss GET verwendet werden, woraufhin
im Response ein Objekt im JSON-Format mit allen Eigenschaften zurückgeliefert
wird. Um ein Objekt, welches ebenfalls im JSON-Format übergeben wird, an die
305 Implementierung
API zu senden, wird POST oder PUT verwendet.
Abb. 5.2: Beispiel-Abfrage aller Azure-Gruppe mit der MSG-API und Graph-
Explorer. Quelle: eigene Abbildung
Diese API-Anfragen sind in dem MSG-Java-SDK ebenfalls vorhanden und kön-
nen somit in Java implementiert werden.
1 IGraphServiceClient graphClient =
GraphServiceClient.builder().authenticationProvider(authProvider).buildClient();
2
3 IGroupCollectionPage groups = graphClient.groups().buildRequest().get();
Listing 5.1: Beispiel-Abfrage aller Azure-Gruppe mit dem Microsoft-Graph-SDK
315 Implementierung
5.3 Zusammenhang zwischen ADITO, Microsoft
Graph-API, Microsoft Azure und Microsoft Teams
In MST gibt es die sogenannten Teams, die einem Gruppenchat mit Besitzer und
Mitglieder entsprechen. Diese Teams sind eine Abbildung einer Microsoft Azure-
Gruppe. Es gibt zwei Typen von Gruppen: “Office-Gruppen“und “Sicherheitsgrup-
pen“. Um aus einer Gruppe heraus ein MST Team zu erstellen wird der Typ “Office-
Gruppe“benötigt. Jedem Team liegt eine Microsoft Azure-Gruppe als Basis-Objekt
zugrunde. Werden in einer dieser Gruppen Daten geändert, so synchronisiert sich
MST mit dem Microsoft Azure-Portal und passt diese automatisch an (vgl. Micro-
soft 2020d).
Abb. 5.3: Kommunikationsübersicht. Quelle: eigene Abbildung
Aus der Abbildung 5.7 wird ersichtlich, wie die verschiedenen Komponenten
zusammenarbeiten. Das ADITO-System ist der Auslöser und stößt die Kommuni-
kation an. Daraufhin wird ein Request gegen die MSG-API gestellt.
Diese kommuniziert mit Microsoft Azure und legt die verschiedenen Daten und
die Struktur von Teams und Kanälen in einem in Azure ausgeführten Chatdienst ab
(vgl. Microsoft 2020c). MST synchronisiert sich automatisch mit Microsoft Azure.
325 Implementierung
5.4 Vorbereitung
Um die Teams-Anbindung, über die MSG-API und OAuth2 nutzen zu können,
müssen einige Einstellungen in Microsoft Azure vorgenommen werden. Die ADITO-
Software muss zuerst als Applikation im Microsoft Azure-Portal, unter dem Menü-
punkt “App-Registrierung“, registriert werden. Bei dieser Registrierung werden,
zum Teil automatisch, spezielle Anmeldedaten erstellt, um sich an dem Authoriza-
tion-Server von Microsoft authentifizieren zu können.
Abb. 5.4: App-Registrierung. Quelle: eigene Abbildung
Nachdem eine neue Applikation registriert wurde, stehen nun zwei Identifi-
kationsnummern in der Übersicht zur Verfügung: “Anwendungs(Client)-ID“und
"Verzeichnis(Mandats)-ID", welche für die OAuth2-Authentifizierung notwendig
sind.
335 Implementierung
Abb. 5.5: App-Registrierung-Übersicht. Quelle: eigene Abbildung
Zusätzlich muss, unter dem Menüpunkt “Zertifikate und Geheimnisse“, ein Pass-
wort oder auch Key genannt, hinterlegt werden, das für den Tokenaustausch benö-
tigt wird.
Abb. 5.6: Key-Registrierung. Quelle: eigene Abbildung
345 Implementierung
Als letzten Schritt der Vorbereitungen müssen der Applikation diverse Rechte
eingeräumt werden, um auf die unterschiedlichen Ressourcen zugreifen zu dürfen.
Dafür müssen im Menüpunkt App-Berechtigungen die passenden ausgewählt und
hinzugefügt werden. Bei diesen Berechtigungen muss zwischen Anwendungs- und
deligierten Berechtigungen unterschieden werden.
Der Unterschied besteht darin, dass Anwendungsberechtigungen einer Anwen-
dung und deligierte Berechtigungen einem angemeldeten Benutzer Zugriff ge-
statten (vgl. Microsoft 2020b). Bei den verschiedenen Berechtigungen ist darauf
zu achten, welcher OAuth2 Flow verwendet wird, um sich dementsprechend au-
thentifizieren zu können, da manche Ressourcen nicht für eine Anwendung zur
Verfügung stehen.
Abb. 5.7: API-Berechtigungen. Quelle: eigene Abbildung
355 Implementierung
5.5 Implementierung
In Abbildung 5.8 wird ein UML-Diagramm in gekürzter Form vorgestellt, in wel-
chem veranschaulicht wird, wie die entwickelten Klassen zusammenhängen und
miteinander kommunizieren.
Abb. 5.8: UML-Diagramm. Quelle: eigene Abbildung
365 Implementierung
5.5.1 public class OAuth2AuthenticationProvider
Die OAuth2AuthenticationProvider-Klasse implementiert das Interface IAuthen-
ticationProvider, welches von dem MSG-Java-SDK zur Verfügung gestellt wird.
Dieses Interface beschreibt die Funktion authenticateRequest, die aufgerufen wird,
wenn ein HTTP-Request gegen die MSG-API erfolgt. Diese Funktion ist notwendig,
um den Request zu authentifizieren. Dies geschieht indem der Access-Token in den
dafür vorgesehenen Authentifizierungs-Header gesetzt wird.
1 /**
2 * Fuegt den Access-Token in den Request-Header hinzu
3 */
4 @Override
5 public void authenticateRequest(IHttpRequest pRequest)
6 {
7 pRequest.addHeader(AUTHORIZATION, BEARER + accessToken);
8 }
Listing 5.2: authenticateRequest
5.5.2 Erzeugen eines OAuth2 Tokens
Bevor HTTP-Requests gesendet werden können, wird ein OAuth2-Token benötigt.
Dieser wird im Konstruktor mit Hilfe der verwendeten Technologie ScribeJava er-
zeugt. Dort wird die Funktion _initOauth2Service aufgerufen und die Daten, die in
der Vorbereitung erstellt worden sind, übergeben. In der Funktion wird die konkre-
te Klasse OAuth20Service, die von der, in Kapitel 5.2.1 erwähnten, OAuthService-
Klasse erbt, verwendet.
“Um die OAuthService-Implementierungen zu erstellen, stellt die Bibliothek einen
ServiceBuilder bereit"(Codeflow 2020).
375 Implementierung
1 /**
2 * Erstellt einen OAuth2 Service mit Hilfe der ScribeJava API
3 * Dieser dient dazu einen Access-Token von Azure Active Directory zu erhalten
4 *
5 * @param pClientId die Client-Id (Azure Active Directory)
6 * @param pTenantId die Tenant-Id (Azure Active Directory)
7 * @param pClientSecret das Client-Secret (Azure Active Directory)
8 * @return einen OAuth2Service
9 */
10 private OAuth20Service _initOAuth2Service(String pClientId, String pTenantId,
String pClientSecret)
11 {
12 return new ServiceBuilder(pClientId)
13 .apiSecret(pClientSecret)
14 .defaultScope(GRAPH_SCOPE)
15 .build(MicrosoftAzureActiveDirectory20Api.custom(pTenantId));
16 }
Listing 5.3: _initOAuth2Service
Nachdem ein OAuth20Service erstellt worden ist, ist es möglich einen soge-
nannten Flow mit Hilfe der mitgelieferten Funktionen der ScribeJava Bibliothek
auszuwählen. Mit getAccessTokenClientCredentialsGrant wird der Client-Credentials
Genehmigungsprozess ausgewählt, welcher der Client-Berechtigung in Kapitel 2.1
entspricht. Über eine weitere Funktion getAccessToken wird der Access-Token abge-
rufen.
385 Implementierung
1 private String accessToken;
2 private OAuth20Service oAuth2Service;
3
4 //Konstruktor fuer Applikation-Tokens
5 public OAuth2AuthenticationProvider(String pClientId, String pTenantId, String
pClientSecret) throws AditoException
6 {
7 oAuth2Service = _initOAuth2Service(pClientId, pTenantId, pClientSecret);
8 try
9 {
10 accessToken =
oAuth2Service.getAccessTokenClientCredentialsGrant().getAccessToken();
11 }
12 catch (IOException | InterruptedException | ExecutionException pEx)
13 {
14 final CheckPointDetails details = new CheckPointDetails("Check the
configuration settings");
15 throw new AditoException(pEx, 58, 35, details);
16 }
17 }
18
19 //Konstruktor fuer User-Tokens
20 public OAuth2AuthenticationProvider(String pClientId, String pTenantId, String
pClientSecret, String pUsername, String pPassword) throws AditoException
21 {
22 oAuth2Service = _initOAuth2Service(pClientId, pTenantId, pClientSecret);
23 try
24 {
25 accessToken = oAuth2Service.getAccessTokenPasswordGrant(pUsername,
pPassword).getAccessToken();
26 }
27 catch (IOException | InterruptedException | ExecutionException pEx)
28 {
29 final CheckPointDetails details = new CheckPointDetails("Check the
configuration settings");
30 throw new AditoException(pEx, 58, 36, details);
31 }
32 }
Listing 5.4: OAuth2AuthenticationProvider Konstruktoren
395 Implementierung
In Listing 5.4 ist zu beachten, dass hier zwischen einem Application-Token
und User-Token unterschieden werden muss. Dies ist zurück zu führen auf die
Anwendungs- und deligierten Berechtigungen in Abschnitt 5.4. Der abgerufene
Access-Token kann somit in die vorher erwähnte authenticateRequest-Funktion ein-
gefügt werden, wenn ein Request erfolgt.
5.5.3 public class TeamsModul
Um den Rahmen dieser Arbeit nicht übermäßig auszureizen wird in den nächsten
Abschnitten nur auf die Anforderung Gruppenchat erstellen eingegangen und diese
im Detail erläutert. Die restlichen umgesetzten Anforderungen werden aufgrund
des Betriebsgeheimnisses nicht veröffentlicht.
Die Klasse TeamsModul enthält alle Funktionen, um die fachlichen Anforderungen
zu erfüllen. In den verschiedenen Methoden wird jeweils mindestens ein Request
abgearbeitet.
5.5.4 Funktion: createTeam
Die Funktion createTeam besteht aus mehreren privaten Funktionen, um den Code
übersichtlich zu halten. Diese werden nachfolgend erläutert.
405 Implementierung
1 /**
2 * Erstellt eine neue Azure Active Directory Gruppe, fuegt dieser Besitzer hinzu
und erstellt daraus ein MicrosoftTeams Team
3 *
4 * @param pGroupConfig Das GruppenConfig Objekt
5 * @param pTeamConfig Das TeamConfig Objekt
6 * @return die Id, DisplayName, GeneralChannelId und WebUrl des erstellten Teams
in einer ScriptableMap
7 * @throws AditoException wird geworfen, wenn ein Fehler auftritt (genauere
Beschreibung, bei den einzelnen inneren Methoden)
8 */
9 public ScriptableMap createTeam(JScriptTeams.GroupConfig pGroupConfig,
JScriptTeams.TeamConfig pTeamConfig) throws AditoException
10 {
11 IGraphServiceClient graphApplicationClient =
_initGraphServiceApplicationClient();
12
13 Group createdGroup = _createNewGroup(graphApplicationClient, pGroupConfig,
List.of(pGroupConfig.getOwnerIds()));
14 Team createdTeam = _createNewTeam(graphApplicationClient, createdGroup.id,
pTeamConfig);
15
16 Map keyValue = new HashMap();
17 keyValue.put("teamId", createdTeam.id);
18 keyValue.put("teamName", createdGroup.displayName);
19 keyValue.put("generalChannelId",
createdTeam.getRawObject().get("internalId").getAsString());
20 keyValue.put("webUrl", createdTeam.webUrl);
21
22 return new ScriptableMap(keyValue);
23 }
Listing 5.5: createTeam
Um ein Team zu erstellen, muss zuerst das Basis-Objekt erstellt werden, das
einem Team übergeordnet ist. Das bedeutet, dass als erstes eine Microsoft Azure-
Gruppe erstellt werden muss. Um diese Gruppe zu erstellen, muss zuerst ein Grup-
penobjekt mit den verschiedenen Eigenschaften erstellt werden. Dieses Erstellen
übernimmt die _createGroupObject-Funktion.
415 Implementierung
1 /**
2 * Erstellt ein neues Group-Objekt mit vordefinierten Einstellungen
3 *
4 * @param pGroupConfig Das GruppenConfig Objekt
5 * @param pAzureOwnerIds die Azure Ids der Besitzer der Gruppe
6 * @return Ein Group-Objekt
7 */
8 private Group _createGroupObject(JScriptTeams.GroupConfig pGroupConfig,
List pAzureOwnerIds)
9 {
10 Group newGroup = new Group();
11 newGroup.displayName = pGroupConfig.getDisplayName();
12 if (StringUtils.isBlank(pGroupConfig.getDescription()) == false)
13 newGroup.description = pGroupConfig.getDescription();
14 newGroup.mailNickname = pGroupConfig.getMailNickName();
15
16 newGroup.securityEnabled = false; //false fuer Office-Gruppen
17 newGroup.mailEnabled = true; //true fuer Office-Gruppen
18
19 //Unified = Office Gruppe
20 LinkedList groupTypesList = new LinkedList();
21 groupTypesList.add("Unified");
22 newGroup.groupTypes = groupTypesList;
23
24 JsonArray owners = _buildMemberJsonArray(pAzureOwnerIds);
25
26 newGroup.additionalDataManager().put("owners@odata.bind", owners);
27 //"Um Verwirrung zu vermeiden, fuegen Sie alle Besitzer auch zur
Mitgliederliste hinzu"(MS Docs)
28 newGroup.additionalDataManager().put("members@odata.bind", owners);
29
30 return newGroup;
31 }
Listing 5.6: _createGroupObject (In _buildMemberJsonArray werden die Ids der
Besitzer in eine notwendige Form gebracht)
425 Implementierung
Nachdem das Gruppen-Objekt erstellt worden ist, kann durch den Aufruf eines
MSG-API-Calls mit Hilfe des MSG-Java-SDK’s eine neue Gruppe erstellt werden,
in welchem das vorher erstelle Gruppenobjekt als Parameter mitgeliefert wird.
1 /**
2 * Erstellt ein neues Gruppenobjekt und fuegt es in Azure Active Directory als
Office365 Gruppe hinzu
3 *
4 * @param pGraphApplicationClient der GraphServiceClient zum Ausfuehren von
GraphAPI-Calls
5 * @param pGroupConfig Das GruppenConfig Objekt
6 * @param pAzureOwnerIds die Azure Ids der Besitzer der Gruppe
7 * @return Das Group-Objekt, welches gerade erstellt worden ist
8 * @throws AditoException wird geworfen, wenn beim GraphAPI-Call etwas schief
laeuft
9 */
10 private Group _createNewGroup(IGraphServiceClient pGraphApplicationClient,
JScriptTeams.GroupConfig pGroupConfig, List pAzureOwnerIds) throws
AditoException
11 {
12 Group newGroup = _createGroupObject(pGroupConfig, pAzureOwnerIds);
13 try
14 {
15 return pGraphApplicationClient.groups().buildRequest().post(newGroup);
16 }
17 catch (ClientException pEx)
18 {
19 final CheckPointDetails details = new CheckPointDetails("GroupConfig: " +
pGroupConfig.toString());
20 throw new AditoException(pEx, 58, 5, details);
21 }
22 }
Listing 5.7: _createNewGroup
435 Implementierung
Wenn das Basisobjekt (Microsoft Azure-Gruppe) erzeugt worden ist, kann das
untergeordnete Objekt “Team“erstellt werden. Dafür muss, wie auch bei einem
Gruppenobjekt, ein Teamobjekt erstellt und die verschiedenen Eigenschaften de-
finiert werden. Die Funktion _createTeamObject besteht lediglich aus Zuweisungen
der übergebenen Parametern an das Teamobjekt. Nachdem dieser Schritt erfolg-
reich abgeschlossen ist, kann mit Hilfe eines weiteren MSG-API-Calls das Team
erstellt werden.
Da in der aktuellen Version des MSG-Java-SDK’s noch keine Möglichkeit besteht
mit Hilfe der mitgelieferten Funktionen einen PUT-Request zum Erstellen von
Teams auszuführen, muss hier ein sogenannter Custom-Request verwendet wer-
den. Bei Custom-Requests werden keine vorgefertigten Bausteine aus dem SDK
benutzt, sondern der API-Aufruf selbst beschrieben. Dadurch kann der Entwickler
entscheiden, welche Http-Methode verwendet wird. Speziell bei dieser Funktion
ist darauf zu achten, falls diese fehlschlägt, dass das vorherige Gruppenobjekt wie-
der gelöscht wird, um zu verhindern, dass eine Gruppe ohne zugehöriges Team
besteht.
445 Implementierung
1 /**
2 * Erstellt aus einer Azure Active Directory Office Gruppe ein neues
MicrosoftTeams Team
3 *
4 * @param pGraphApplicationClient der GraphServiceClient zum Ausfuehren von
GraphAPI-Calls
5 * @param pGroupId die Gruppen Id von einer Azure Active Directory Gruppe
6 * @return Das Team-Objekt, welches gerade erstellt worden ist
7 * @throws AditoException wird geworfen, wenn beim GraphAPI-Call etwas schief
laeuft
8 */
9 private Team _createNewTeam(IGraphServiceClient pGraphApplicationClient, String
pGroupId, JScriptTeams.TeamConfig pTeamConfig) throws AditoException
10 {
11 CustomRequest createTeamCustomRequest =
pGraphApplicationClient.customRequest("/groups/" + pGroupId +
12 "/team", Team.class)
13 .buildRequest();
14 createTeamCustomRequest.setMaxRetries(3);
15 createTeamCustomRequest.setDelay(10);
16
17 Team newTeam = _createTeamObject(pTeamConfig);
18
19 try
20 {
21 return createTeamCustomRequest.put(newTeam);
22 }
23 catch (ClientException pEx)
24 {
25 //Falls das Team erzeugen ein Fehler schmeisst, loesche die Gruppe wieder,
damit sie nicht alleine existiert
26 _deleteGroup(pGraphApplicationClient, pGroupId, true);
27 //Wenn das Loeschen problemlos verlaeuft, schmeisse die createTeamException
28 final CheckPointDetails details = new CheckPointDetails("GroupId: " +
pGroupId, "TeamConfig: " + pTeamConfig.toString());
29 throw new AditoException(pEx, 58, 6, details);
30 }
31 }
Listing 5.8: _createNewTeam
455 Implementierung
Nachdem alle Funktionen abgeschlossen sind, wurde ein neues Team in MST per
Code mit Hilfe der MSG-API erstellt.
5.5.5 public class JScriptTeams
Die JScriptTeams Klasse ist das Verbindungsstück zwischen dem in Abschnitt 2.2.3
erwähnten ADITO Designer und dem Kern der ADITO-Software. In dieser Klas-
se wird eine eigene API für ADITO spezifische Anwendungen entwickelt, die im
Customizing auf verschiedene Arten eingesetzt werden kann. Über die Annotati-
on @JSSTUP wird eine JavaScript-Bibliothek erstellt. Somit können die Funktionen
dieser Bibliothek im ADITO Designer aufgerufen werden. Dadurch kann die entwi-
ckelte Funktion ein MST Team zu erstellen an verschiedene Komponenten geknüpft
werden, um diese zur Laufzeit des Programms auszulösen.
1 /**
2 * Erstellt eine neue Azure Active Directory Gruppe, fuegt dieser Besitzer hinzu
und erstellt daraus ein MicrosoftTeams Team
3 *
4 * @param pGroupConfig Das GruppenConfig Objekt
5 * @param pTeamConfig Das TeamConfig Objekt
6 * @return die Id, DisplayName, GeneralChannelId und WebUrl des erstellten Teams
in einer ScriptableMap
7 * @throws AditoException wird geworfen, wenn ein Fehler auftritt
8 */
9 @JSSTUB(isDocumented = false)
10 public ScriptableMap createTeam(GroupConfig pGroupConfig, TeamConfig pTeamConfig)
throws AditoException
11 {
12 pGroupConfig.validate();
13 return teamsModul.createTeam(pGroupConfig, pTeamConfig);
14 }
Listing 5.9: createTeam (Das TeamConfig-Objekt muss nicht validiert werden weil
alle Attribute einen default Wert besitzen und deshalb optional sind)
46Sie können auch lesen
