Dokumentation zur betrieblichen Projektarbeit...Abschlussprüfung Sommer 2018 Fachinformatiker für...

Abschlussprüfung Sommer 2018

Fachinformatiker für Anwendungsentwicklung

Dokumentation zur betrieblichen Projektarbeit

Service-Bot

Entwicklung eines Chatbots zur Unterstützung des Kundenservice

Abgabetermin: 25.04.2018

Prüfungsbewerber:

Jim Eidmann

Lange Straße 52

37181 Hardegsen

Ausbildungsbetrieb: Dr. Kuhl Unternehmensberatung GmbH & Co. KG

Schmiedewiese 1

37181 Hardegsen

Service-Bot Entwicklung eines Chat-Bot zur Unterstützung des Kundenservice

Jim Eidmann I

Inhaltsverzeichnis

Abbildungsverzeichnis

Tabellenverzeichnis

Abkürzungsverzeichnis

1. Einleitung ....................................................................................................................................... 1

1.1 Projektbeschreibung ................................................................................................................ 1

1.2 Projektziel ................................................................................................................................ 1

1.3 Projektumfeld .......................................................................................................................... 2

1.4 Projektschnittstellen ................................................................................................................ 2

1.5 Projektabgrenzung ................................................................................................................... 2

2. Projektplanung .............................................................................................................................. 3

2.1 Projektphasen .......................................................................................................................... 3

2.2 Ressourcenplanung .................................................................................................................. 3

2.3 Entwicklungsprozess ............................................................................................................... 3

3. Analysephase .................................................................................................................................. 4

3.1 Ist-Analyse............................................................................................................................... 4

3.2 Wirtschaftlichkeitsanalyse ....................................................................................................... 4

3.3 „Make or Buy“-Entscheidung ................................................................................................. 4

3.4 Projektkosten ........................................................................................................................... 4

3.5 Amortisationsdauer ................................................................................................................. 5

3.6 Nicht-monetäre Vorteile .......................................................................................................... 6

3.7 User-Storys .............................................................................................................................. 7

3.8 Lastenheft ................................................................................................................................ 7

4. Entwurfsphase ............................................................................................................................... 7

4.1 Zielplattform ............................................................................................................................ 7

4.2 Softwarearchitektur ................................................................................................................. 7

4.3 Produktumgebung ................................................................................................................... 8

4.4 Datenmodell ............................................................................................................................ 9

4.5 Pflichtenheft .......................................................................................................................... 10

5. Implementierungsphase .............................................................................................................. 10

5.1 Iterationsplanung ................................................................................................................... 10

5.2 Implementierung der Datenstrukturen ................................................................................... 10

5.3 Einrichtung der Entwicklungsumgebung .............................................................................. 10

5.4 Implementierung der Services ............................................................................................... 11

5.5 Implementierung der Konversationslogik ............................................................................. 13


Jim Eidmann II

6. Abnahme- und Einführungsphase ............................................................................................. 14

6.1 Abnahme durch die Service-Abteilung ................................................................................. 14

6.2 Veröffentlichung und Einführung ......................................................................................... 14

6.3 Dokumentation ...................................................................................................................... 14

7. Fazit .............................................................................................................................................. 15

7.1 Soll/ Ist-Vergleich ................................................................................................................. 15

7.2 Gewonnene Erkenntnisse ...................................................................................................... 15

7.3 Ausblick................................................................................................................................. 15

A Anhang

A.1 Detaillierte Zeitplanung ……………………………………………………………………………………………………………... V

A.2 Verwendete Ressourcen ……………………………………………………………………………………………………………..VI

A.3 Trello – Kanban-Board ………………………………………………………………………………………………………………VII

A.4 Auszug Lastenheft zur Erstellung eines Chat-Bots……………………………………………………………………. VII

A.5 Entity-Relationship-Modell ………………………………………………………………………………………………………. IX

A.6 Tabellenmodell …………………………………………..…………………………………………………………………………….. IX

A.7 Auszug Pflichtenheft zur Erstellung eines Chat-Bots …………………………………………………………..…….. X

A.8 Iterationsplan zur Entwicklung eines Chat-Bots………………….……………………………………………………… XI

A.9 LUIS Klassen …………………………………………….…………………………………..………………………………….……… XI

A.10 LUIS Entity abfragen ………………………….…………………………………..……..…………………..…………………. XII

A.11 JSON Beispiel …………….…………………………………..…….……………………………………………..…..……..…… XIV

A.12 Root Dialog (Ausschnitt) …………………………………..…….………………………………………….………………… XV

A.13 QnA-Maker Dialog (Ausschnitt) …………………..…….………………………………………….………………….… XVI

A.14 Feedback Dialog (Ausschnitt) …..….………………………………..………….…….…………………………….…… XVIII

A.15 E-Mailadressen auf Duplikate prüfen und speichern …………………………….…….………………………… XXII

A.16 Benutzerhandbuch (Ausschnitt) …………….…….…………………………………………………………………….… XXIV


Jim Eidmann III

Abbildungsverzeichnis

Abbildung 1: Produktumgebung ................................................................................................ 9

Abbildung 2: Trello ................................................................................................................. VII

Abbildung 3: Entity-Relationship-Modell ............................................................................... IX

Abbildung 4: Tabellenmodell ................................................................................................... IX

Tabellenverzeichnis

Tabelle 1: Grobe Zeitplanung .................................................................................................... 3

Tabelle 2: Ressourcenplanung ................................................................................................... 5

Tabelle 3: Amortisationsdauer pro Monat ................................................................................. 6

Tabelle 4: LUIS ........................................................................................................................ 12

Tabelle 5: Soll/ Ist-Vergleich ................................................................................................... 15

Tabelle 6: Detaillierte Zeitplanung ........................................................................................... V


Jim Eidmann IV

Abkürzungsverzeichnis

DKUB Dr. Kuhl Unternehmensberatung GmbH & Co. KG

MuK MeyerundKuhl Spezialwäschen GmbH

ERM Entity-Relationship-Modell

FAQ Frequently Asked Questions / Häufig gestellte Fragen

SQL Structured Query Language

QnA Question and Answer

LUIS Language Understanding Intelligent Service

NuGet Open Source Paketverwaltung für Softwareentwicklung in .NET

KVP Kontinuierlicher Verbesserungsprozess

REST Representational State Transfer

API Application Programming Interface

ERM Entity Relationship Modell

JSON JavaScript Object Notation

IIS Internet Information Services

http Hypertext Transfer Protocol

URL Uniform Resource Locator


Jim Eidmann 1

1. Einleitung

Die folgende Projektdokumentation schildert den Ablauf des IHK-Abschlussprojektes, welches

der Autor im Rahmen seiner Ausbildung zum Fachinformatiker Anwendungsentwicklung

durchgeführt hat. Der Ausbildungsbetrieb ist die Dr. Kuhl Unternehmensberatung GmbH & Co.

KG, im Folgenden DKUB genannt, eine unabhängige Management- und IT-Beratung mit Fokus

auf den Mittelstand. Die DKUB ist unter anderem zuständig für die Analyse und Optimierung

interner Prozesse und Abläufe und für die Auswahl und Einführung von maßgeschneiderten und

leistungsfähigen Softwarelösungen. Ein Partnerunternehmen der DKUB ist die MeyerundKuhl

Spezialwäschen GmbH, im Folgenden MuK genannt. Sie ist spezialisiert auf die Pflege und PFC-

freie Imprägnierung von Outdoor- und Funktionstextilien. Dieser Service wird u.a. über einen

Webshop angeboten.

1.1 Projektbeschreibung

In diesem Projekt wurde eine Softwarelösung in Form eines Chat-Bots für die MuK entwickelt, im

Folgenden auch Service-Bot genannt. Dieser dient hauptsächlich der automatischen Beantwortung

von Kundenfragen. Da die meisten Fragen von Kunden oder Kaufinteressenten im Webshop eines

Unternehmens auftreten, wird der Bot über den Webshop zur Verfügung gestellt. Mit dem Chat-

Bot ist es möglich, dass Kunden zu jeder Zeit eine kompetente Antwort auf ihre Anfrage

bekommen. Außerdem gibt es die Möglichkeit, einmalig Feedback zur Internetpräsenz zu geben,

damit diese stetig verbessert werden kann. Die Feedback-Funktion wurde durch eine vordefinierte

Umfrage implementiert. Der Bot ist technisch dazu in der Lage, auf das gegebene Feedback

einzugehen und entsprechende Fragen zu stellen. Der Kunde war bisher darauf angewiesen, dass

ein Mitarbeiter sich persönlich um seine Anfrage kümmert, was je nach Auslastung

unterschiedlich lange dauern und nur innerhalb der Bürozeiten erfolgen konnte.

1.2 Projektziel

Das Ziel des Projektes war es, dem Kunden die Möglichkeit zu geben, noch während des

Bestellprozesses, jederzeit Fragen stellen zu können. Dabei ist es irrelevant, ob der Kunde Fragen

zum Ablauf, zu den Preisen oder zu seinem Auftrag hat.

Mithilfe dieser Lösung soll sowohl das Kundenerlebnis stark verbessert, als auch die Service-

Abteilung entlastet und unterstützt werden.


Jim Eidmann 2

1.3 Projektumfeld

Auftraggeber des Projektes ist die Service-Abteilung der MuK. Zu den Aufgaben der Abteilung

gehört unter anderem die Beantwortung von Kundenanfragen per Telefon und E-Mail. Außerdem

die Weiterleitung und Verarbeitung von Kunden-Feedback, die Anregung zur Verbesserung im

Rahmen des KVP und die Ausarbeitung von FAQs und sonstigen Hilfsdokumenten. Die MuK hat

sehr verschiedene Kundengruppen. Diese gehen von Feuerwehren über Outdoor-Kunden zu

Motorradfahrern. Aber auch speziellere Kunden, wie Gasthäuser, die ihre Sonnenschirme waschen

wollen. Durch die breite Masse an verschiedenen Textilien und Kundengruppen wird der Support

teilweise immens komplex.

Um dem Kunden-Service die Beantwortung wiederkehrender Fragen und das hohe Aufkommen

an Support-Fällen zu erleichtern, soll der Chat-Bot diese teilweise übernehmen.

1.4 Projektschnittstellen

Damit der Chat-Bot sowohl mit dem Kunden als auch mit der Service-Abteilung kommunizieren

kann, muss er von der Cloud-Plattform Microsoft Azure, die von der DKUB festgelegt wurde,

gehostet werden. Dadurch soll der Chat-Bot unter anderem mit dem Webshop der Wäscherei

arbeiten können.

Das Frontend des Bots wurde mittels iFrame in den Webshop eingebunden. Sämtliche Daten

werden mittels Microsoft Azure in einer Microsoft SQL-Datenbank abgelegt. Diese ist unter

anderem für die Speicherung von bereits vorhandenen Teilnehmern der Feedback-Umfrage

verantwortlich. Damit der Aufwand für die Service-Abteilung so gering wie möglich ist, wurde

der QnA-Maker von Microsoft in den Quellcode des Service-Bots eingebunden. Dadurch ist es

möglich, den Bot über die Website, mit Fragen und entsprechenden Antworten zu füllen.

Zur Ergänzung wurde der Service LUIS (Language Understanding Intelligent Service) verwendet,

um zu erreichen, dass der Kunde auch dann verstanden wird, wenn er keine genormten Sätze

verwendet.

1.5 Projektabgrenzung

Es handelt sich um ein komplett eigenständiges Projekt, ohne Bezug zu anderen

Projekten/Teilprojekten. Die Realisierung des Webshops und die Erarbeitung inhaltlicher

Fragestellungen waren nicht Teil des Projektes.


Jim Eidmann 3

2. Projektplanung

2.1 Projektphasen

Für die Umsetzung des Projektes standen dem Autor insgesamt 70 Stunden zur Verfügung. Diese

wurden auf im Unternehmen bereits festgelegte Phasen verteilt. Die grobe Zeitplanung lässt sich

der folgenden Tabelle entnehmen.

Projektphase Geplante Zeit

Anforderungsdefinition 14 Stunden

Konzeption und

Entwicklung

42 Stunden

Systemintegration und

Tests

14 Stunden

Gesamt 70 Stunden

Tabelle 1: Grobe Zeitplanung

Die einzelnen Hauptphasen wurden in Unterpunkte aufgeteilt. Die Übersicht befindet sich im

Anhang A.1: Detaillierte Zeitplanung.

2.2 Ressourcenplanung

Da es sich bei der MuK um ein recht junges Unternehmen handelt, das sich noch im Aufbau

befindet, wurde darauf geachtet, dass die Anschaffungs- und Folgekosten des Projektes möglichst

gering ausfallen. Deshalb wurde das komplette Projekt mittels kostenloser Services und Software

entwickelt und aufgesetzt. In der Übersicht im Anhang A.2: Verwendete Ressourcen befinden sich

alle Personal-, Hardware- und Softwarekosten, die in dem Projekt verwendet wurden.

2.3 Entwicklungsprozess

Um eine flexible Umsetzung der Anforderungen zu ermöglichen, hat sich der Autor für einen

agilen Entwicklungsprozess entschieden. Da es sich um ein vergleichsweise kleines Projekt mit

wenigen Projektteilnehmern handelt, wurde die agile Methode Kanban verwendet.

Die Methode Kanban ermöglicht die flexible Änderung der Anforderungen und einen fließenden

Entwicklungsprozess, ohne dabei viele Einschränkungen zu definieren.


Jim Eidmann 4

Die Umsetzung erfolgte mithilfe eines Kanban-Boards, das in der Projektmanagementsoftware

„Trello“ angelegt und verwaltet wurde. Ein Ausschnitt dieses Boards befindet sich im Anhang

A.3: Trello – Kanban-Board.

3. Analysephase

3.1 Ist-Analyse

Wie bereits im Abschnitt 2. Projektbeschreibung erwähnt, hat die MuK ein hohes Aufkommen

von Support-Fällen registriert. Dabei handelt es sich vor allem um Telefonanrufe von Kunden oder

Kaufinteressenten, die Fragen zum Ablauf, dem Imprägnierungsverfahren oder zu bestimmten

Textilien haben. Bisher war es dem Kunden lediglich per E-Mail oder Telefon möglich, eine

Auskunft über die genannten Themen zu bekommen. Dies ist mit einer entsprechenden zeitlichen

Verzögerung verbunden, da die Service-Abteilung an ihre Arbeitszeiten gebunden und teilweise

bereits voll ausgelastet ist. Dadurch verzögert sich der Ablauf und bietet kein optimales

Kundenerlebnis.

3.2 Wirtschaftlichkeitsanalyse

Aufgrund der hohen Auslastung der Service-Abteilung und der Art und Menge der

Supportanfragen, war das Projekt dringend zu empfehlen. Ob es auch wirtschaftlich sinnvoll ist,

soll im Folgenden geklärt werden.

3.3 „Make or Buy“-Entscheidung

Da es sich bei der MuK um ein sehr spezielles Unternehmen, mit einem noch spezielleren Ablauf

handelt und der Chat-Bot flexibel erweiterbar sein muss, ließ sich keine den Anforderungen

entsprechende Standard-Lösung am Markt finden. Aus diesem Grund sollte das Projekt in

Eigenentwicklung durchgeführt werden.

3.4 Projektkosten

Nachfolgend befinden sich die kalkulierten Kosten, die während der Entwicklung des Projektes

anfielen. Dabei werden sowohl die Personal-, als auch die Hard- und Softwarekosten

berücksichtigt.


Jim Eidmann 5

Da die exakten Personalkosten aus Datenschutzgründen nicht herausgegeben werden dürfen,

wurde die Kalkulation anhand von beispielhaften Kosten durchgeführt. Die Gesamtkosten eines

Mitarbeiters für das Unternehmen betragen demnach 50,00 €, die eines Auszubildenden 20,00 €.

Für die sonstigen Kosten wurde ein pauschaler Satz von 10,00 € pro Stunde verwendet.

Sämtliche anfallende Projektkosten, können der folgenden Tabelle entnommen werden.

Vorgang Mitarbeiter Zeit Personal Sonstige

Kosten

Gesamt

Anforderungs-

definition

1x Auszubildender 14 Std. 280,00 € 140,00 € 420,00 €

Entwicklung 1x Auszubildender 56 Std. 1.120 € 560,00 € 1.680,00 €

Code-Review 1x Mitarbeiter 3 Std. 150,00 € 30,00 € 180,00 €

Abnahme 1x Mitarbeiter 1 Std. 50,00 € 10,00 € 60,00 €

2.340,00 €

Tabelle 2: Ressourcenplanung

3.5 Amortisationsdauer

Im Folgenden soll geprüft werden, ab welchem Zeitpunkt sich das Projekt amortisiert. Dazu

werden die Anschaffungskosten (Entwicklungskosten) durch die laufende Kostenersparnis

dividiert. Einige dieser Services sind nur bis zu einem bestimmten Volumen kostenlos und müssen

bei einer Auslastung von mehr als 10.000 Transaktionen bezahlt werden. Da es unwahrscheinlich

ist, dass diese Auslastung in nächster Zeit erreicht wird, wurden diese zusätzlichen Kosten nicht

in die Amortisationsrechnung aufgenommen. Da es kaum möglich ist, die Anzahl an

Supportanfragen vorauszusehen, hat der Autor die Daten der letzten 3 Monate ausgewertet und

mit dem Durchschnitt davon gearbeitet.


Jim Eidmann 6

Vorgang Zeit

pro Vorgang

Anzahl (alt)

pro Monat

Anzahl (neu)

pro Monat

Einsparung

pro Monat

Fragen zum

Ablauf

10 Minuten 15 8 70 Minuten

Fragen zum

Preis


Fragen zu

bestimmtem

Artikel


Fragen zur

Waschbarkeit


324 Minuten

Tabelle 3: Amortisationsdauer pro Monat

Berechnung der Amortisationsdauer:

324 Min/Monat x 12 Monate/Pro Jahr = 3.888 Min/Jahr = 64,80 h/Jahr

64,80 h/Jahr x (50€ + 30€)1 = 5.184€/Jahr

2.340€ / 5.184€ = 0,45 Jahre ≈ 5 Monate und 2 Wochen

Die Projektkosten amortisieren sich nach der oben ausgeführten Berechnung, in 5 Monaten und 2

Wochen.

3.6 Nicht-monetäre Vorteile

Die nicht-monetären Vorteile teilen sich in die Vorteile für den Kunden und die Vorteile für die Mitarbeiter

der Service-Abteilung.

Der Kunde hat durch das Projekt die Möglichkeit, jederzeit und von überall seine Fragen und Probleme

mitzuteilen und kompetente Hilfe zu erhalten.

Bei den Mitarbeitern entsteht geringerer Aufwand. Dadurch können sie sich besser auf ihre anderen

Aufgaben konzentrieren, was sowohl die Effizienz als auch das Betriebsklima verbessert.

___________________________________

1 Personalkosten + sonstige Kosten


Jim Eidmann 7

3.7 User-Storys

Um die Anforderungen der Kunden und der Mitarbeiter abzudecken, wurden mithilfe der Service-

Abteilung User-Storys erstellt, die der Bot abdecken soll. Eine User-Story, auf Deutsch

Anwendererzählung genannt, ist eine in Umgangssprache formulierte Anforderung an eine Software. Diese

Methode hat sich angeboten, da es sich um einen agilen Entwicklungsprozess handelt.

Die User-Storys wurden ins Lastenheft übernommen.

3.8 Lastenheft

Zusammen mit der MuK wurde als Ergebnis der Analysephase ein Lastenheft erstellt. Dieses

wurde mithilfe der bereits erwähnten User-Storys umgesetzt. Ein Ausschnitt davon befindet sich

im Anhang A.4: Auszug Lastenheft zur Entwicklung eines Chat-Bots.

4. Entwurfsphase

4.1 Zielplattform

Das Projekt wurde mithilfe des Microsoft Bot Frameworks entwickelt, da es die einzige Lösung

ist, die alle benötigten Services (LUIS, QnA-Maker) / Anforderungen unterstützt. Die fertige

Software-Lösung wird in Microsoft Azure gehostet, um eine möglichst hohe Erreichbarkeit zu

ermöglichen. Außerdem wurde der Bot an eine, ebenfalls in Microsoft Azure gehostete, SQL-

Datenbankinstanz angebunden, um dort bestimmte Informationen abzuspeichern.

Bei der Auswahl der Programmiersprache waren die Möglichkeiten eingeschränkt, da das

Microsoft Bot Framework lediglich C# und Node.JS unterstützt. Aufgrund dieser Einschränkung

und den Kenntnissen des Autors, bzw. des Unternehmens wurde als Programmiersprache C#

gewählt. Auf die Erstellung einer Nutzwertanalyse zur Auswahl der Programmiersprache wurde

deshalb verzichtet.

4.2 Softwarearchitektur

Das Microsoft Bot Framework beinhaltet einen Connector, der mittels REST-API auf

verschiedene Kanäle zugreifen kann. Zu den Kanälen gehören unter anderem E-Mail, Skype, SMS,

Telegram und eine Weboberfläche, die per iFrame eingebunden wird. Dadurch ist es dem Bot

möglich, Nachrichten von verschiedenen sozialen Medien zu empfangen und zu interpretieren.

Die Interpretation der empfangenen Nachricht erfolgt über den Message Controller. Wenn es sich


Jim Eidmann 8

bei der Nachricht um eine Benutzer-Nachricht handelt, wird sie an den Root Dialog

weitergegeben, der entscheidet, was damit passiert. Ein Dialog ist dafür zuständig, den

Konversationsfluss zu steuern. Dafür kann der Root Dialog auch weitere Dialoge aufrufen und zur

Laufzeit schließen, wenn sie nicht mehr benötigt werden. Ein Dialog erbt seine Eigenschaften von

der Oberklasse IDialog.

Der Chat-Bot hat die Besonderheit, dass er sowohl Fragen beantworten kann, als auch

Funktionalitäten beinhaltet, die allgemeines Sprachverständnis erfordern. Dazu muss mit zwei

verschiedenen Services von Microsoft gearbeitet werden.

Zum einen mit dem QnA-Maker (Preview), der für die Beantwortung von Fragen zuständig ist.

Zum anderen mit LUIS, um das Sprachverständnis zu ermöglichen.

Damit das Feedback der Kunden und ihre dazugehörige E-Mail-Adresse später ausgewertet

werden können, werden sie in einer Microsoft SQL-Datenbank gespeichert. Außerdem wird

geprüft, ob der Kunde mit dieser E-Mail-Adresse bereits an der Feedback-Umfrage teilgenommen

hat.

4.3 Produktumgebung

Abhängig davon, über welchen Kanal der Kunde den Bot anschreibt, wird die Nachricht entweder

per REST-API (Alle sozialen Netzwerke/Messenger) oder über den im Webshop eingebundenen

iFrame an den Bot Connector übertragen. Dieser gibt die Nachricht an den Chat-Bot weiter.

Der Bot ruft anschließend LUIS auf, um die Interpretation der linguistischen Frage zu definieren.

Je nach Intention der Nachricht greift er nun per REST-API auf LUIS oder den QnA-Maker zu.

Die Mitarbeiter der MuK können per Application Insights von Microsoft Azure die

Zugriffsstatistiken einsehen.


Jim Eidmann 9

In der folgenden Abbildung ist die beschriebene Produktumgebung grafisch veranschaulicht.

Abbildung 1: Produktumgebung

4.4 Datenmodell

Damit das Feedback des Kunden später ausgewertet werden kann, müssen die Daten in einer SQL-

Datenbank gespeichert werden. Dies geschieht erst, nachdem der Kunde seine E-Mail-Adresse

hinterlegt hat und diese noch nicht vorhanden ist. Dadurch wird garantiert, dass keine Spam-Bots

oder Menschen mit unlauteren Absichten das Ergebnis verfälschen können.

Zur Abspeicherung strukturierter Daten wurde zunächst eine Analyse der Feedback-Umfrage und

ihrer möglichen Antworten durchgeführt. Dabei wurde die Art der Daten und ihre entsprechenden

Beziehungen extrahiert. Aus diesen wurde anschließend ein Entity-Relationship-Modell, im

Folgenden ERM genannt, erstellt.

Dieses befindet sich im Anhang A.5: Entity-Relationship-Modell. Folgende Entitätstypen wurden

herausgearbeitet und abgebildet: Kunde, Feedback, Frage, Sonstige.

Da eine relationale Datenbank verwendet werden sollte, wurde das ERM in ein Tabellenmodell

überführt. Das Diagramm befindet sich im Anhang A.6: Tabellenmodell.


Jim Eidmann 10

4.5 Pflichtenheft

Am Ende der Entwurfsphase wurde, als Ergebnis der Konzeption, ein Pflichtenheft erstellt. Dieses

beruht auf dem Lastenheft und definiert die Anforderungen der MuK. Es ist somit die Grundlage

für das durchzuführende Projekt. Einen Auszug vom Pflichtenheft befindet sich im Anhang A.7:

Auszug Pflichtenheft zur Entwicklung eines Chat-Bots.

5. Implementierungsphase

5.1 Iterationsplanung

Da es sich bei dem gewählten Entwicklungsprozess um Kanban handelt, ist es nicht zwingend

erforderlich, Iterationen festzulegen. Dennoch hat der Autor sich dafür entschieden, eine

Iterationsplanung durchzuführen, um die verfügbare Entwicklungszeit präzise ausnutzen zu

können.

Da von den vier User Storys zumindest drei einen ähnlichen zeitlichen Aufwand haben, wurde

jeweils eine User Story in eine Iteration überführt. Die User Storys wurden anschließend in

einzelne Aufgaben aufgeteilt und dem entsprechenden Eigentümer zugewiesen. Zusätzlich

hinzugefügt wurden lediglich die Erstellung der Datenbank, die Implementierung der

grundlegenden Konversationslogik und die Veröffentlichung in Microsoft Azure. Der erstellte

Iterationsplan befindet sich im Anhang A.8: Iterationsplan zur Entwicklung eines Chat-Bots.

5.2 Implementierung der Datenstrukturen

Auf Basis der in 4.4 Datenmodell beschriebenen Datenstruktur wurde die Implementierung der

Datenbank durchgeführt. Dazu wurde eine neue Datenbankinstanz in Microsoft Azure bestellt und

ein neues Schema mit dem Namen „BotData“ angelegt. Anschließend wurden die benötigten

Tabellen mithilfe des Microsoft SQL Server Management Studios angelegt.

5.3 Einrichtung der Entwicklungsumgebung

Als Entwicklungsumgebung wird Visual Studio Professional 2017 von Microsoft verwendet.

Grund dafür ist die hervorragende Unterstützung der Programmiersprache C# und die komfortable

Verwendung des Microsoft Bot Frameworks. Um mit Visual Studio 2017, im Folgenden VS2017


Jim Eidmann 11

genannt, Bots entwickeln zu können, muss zuerst das Projekttemplate heruntergeladen und in das

entsprechende Verzeichnis kopiert werden.

Dieses befindet sich in Windows normalerweise unter:

%USERPROFILE%\Documents\Visual Studio 2017\Templates\ProjectTemplates\Visual C#\

Außerdem müssen die Item-Templates (Controller und Dialog) in das Item-Template Verzeichnis

kopiert werden.

Dieses befindet sich in Windows normalerweise unter:

%USERPROFILE%\Documents\Visual Studio 2017\Templates\ItemTemplates\Visual C#\

Danach kann ein Bot-Projekt erstellt werden. Innerhalb des Projektes muss noch das NuGet-

Package „Microsoft.Bot.Builder“ und das NuGet-Package „QnAMakerDialog“ eingebunden

werden. Dies ist notwendig um auf den QnA-Maker zugreifen zu können. Zum Testen des Chat-

Bots wird eine lokale Version von IIS Express und der Microsoft Bot Emulator installiert.

5.4 Implementierung der Services

Nachdem die Entwicklungsumgebung eingerichtet ist, kann mit der eigentlichen Programmierung

begonnen werden. Im ersten Iterationsschritt hat der Autor die Implementierung des QnA-Makers

umgesetzt. Dazu musste auf der offiziellen Website des Microsoft QnA-Makers ein neuer Service

angelegt werden.

Der Service stellt den Subscription-Key und die Knowledgebase-ID bereit, welche dem Bot zur

Authentifizierung beim QnA-Maker Service dienen. Danach muss auf der Webseite ein FAQ

hinterlegt werden. Das FAQ kann entweder eine PDF-Datei oder eine Internetseite mit einem

entsprechenden FAQ sein. Hier wurde von der Service-Abteilung eine PDF-Datei erstellt, die alle

bereits bekannten Fragen abdeckt. Nachdem der Service fertig eingerichtet ist, werden die

Zugangsdaten im Quellcode des eigentlichen Entwicklungsprojektes hinterlegt, damit mithilfe des

QnA-Maker Dialogs darauf zugegriffen werden kann.

Dazu muss ein neuer Dialog erstellt werden, der vom Root Dialog aufgerufen wird, wenn der

Kunde eine Frage stellt. Um dies zu gewährleisten soll der Bot verstehen, was der Kunde von ihm

will, noch bevor der Dialog des QnA-Makers aufgerufen wird.

Um die Anforderung des linguistischen Sprachverständnisses erfüllen zu können, wird der Service

LUIS in den Bot eingebunden. Dieser sorgt mittels maschinellem Lernen für die benötigte


Jim Eidmann 12

Verarbeitung der Nachricht und wird außerdem für alle weiteren Funktionalitäten, zum Beispiel

der Feedback-Umfrage, benötigt.

Zur Einbindung von LUIS wird, wie beim QnA-Maker, ein neuer Service auf der Website

angelegt. Beim Erstellen wird der Service-Name, die zu verstehende Sprache und eine kurze

Beschreibung hinterlegt. Sobald der Service erfolgreich angelegt wurde, können neue Intents

hinzugefügt werden. Ein Intent, auf Deutsch „Absicht“, ist die Absicht des Anwenders in einem

Wort zusammengefasst. Den Intents werden die entsprechenden Utterances hinzugefügt.

Utterance, auf Deutsch „Äußerung“, bezeichnet einen Satz, den der Anwender dem Bot schreibt.

Abschließend werden die Entities festgelegt. Ein Entity, auf Deutsch „Objekt“, bezeichnet ein

Wort, das die detaillierte, relevante Information des Satzes kennzeichnet. Im Folgenden befindet

sich ein Beispiel für alle drei Erklärungen.

Intent User Utterance Entities

Feedback Ich würde gerne eine

Bewertung abgeben.

Bewertung

Frage Ich würde gern was fragen. fragen

Smalltalk Wie ist das Wetter heute? Wetter

Tabelle 4: LUIS

Nachdem alle benötigten Werte hinzugefügt und definiert sind, wird der Service veröffentlicht,

wobei diese natürlich regelmäßig erweitert werden müssen. Dies geschieht ebenfalls über die

Webseite per Knopfdruck. Dabei wird eine Verknüpfung mit einem entsprechenden Schlüssel

erstellt, über den auf den Service zugegriffen werden kann. Um die Werte interpretieren zu können,

wird bei der Veröffentlichung eine JSON-Datei erstellt, die mithilfe von VS2017 als Klasse

eingefügt wird. Dafür muss lediglich mithilfe der in VS2017 integrierten Funktionalität „Inhalte

einfügen“, bzw. „JSON als Klassen einfügen“ die JSON-Datei eingefügt werden. Die

entsprechenden Klassen LUIS, Rootobject, TopscoringIntent, Intent und Entity befinden sich mit

den entsprechenden Get- und Set-Methoden im Anhang A.9: LUIS Klassen.

Um die Nachricht des Benutzers an den LUIS Service weiterzuleiten, wird eine Funktion

implementiert, welche die Nachricht an die URL anhängt und über eine http-Anfrage aufruft. Der

Quellcode dieser Funktion befindet sich im Anhang A.10: LUIS Entity abfragen. Als Rückgabe

erhält der Chat-Bot, eine JSON-Datei, die von der LUIS Klasse verarbeitet wird. Zur besseren

Veranschaulichung befindet sich eine beispielhafte JSON-Datei im Anhang A.11: JSON Beispiel.


Jim Eidmann 13

Dort sieht man, dass zur Abfrage alle Intents eine Wahrscheinlichkeit zugewiesen bekommen. Am

Ende wird das Intent ausgewählt, das die größte Wahrscheinlichkeit hat, also die Intention des

Anwenders am besten wiederspiegelt.

5.5 Implementierung der Konversationslogik

Nachdem die Services eingebunden sind, wird die eigentliche Konversationslogik implementiert.

Beim Empfang einer Benutzer-Nachricht durch den Message Controller, wird der Root Dialog

aufgerufen. Dieser interpretiert mithilfe von LUIS die Nachricht und ruft den entsprechenden

Dialog auf. Ein Ausschnitt des Root Dialogs befindet sich im Anhang A.12: Root Dialog

(Ausschnitt). Wenn der Anwender eine Frage stellt, wird der QnA-Maker Dialog aufgerufen, der

die Frage, sofern möglich, beantwortet. Falls der Chat-Bot keine passende Antwort geben kann,

wird eine Meldung an den Benutzer geschickt. Da es sich bei dem QnA-Maker bereits um eine

fertige Lösung handelt, wurden einige Methoden überschrieben und angepasst. Ein Ausschnitt

davon befindet sich im Anhang A.13: QnA-Maker Dialog (Ausschnitt).

Wenn der Anwender an der Feedback-Umfrage teilnehmen möchte, wird der Feedback Dialog

aufgerufen und ihm werden eine Reihe von Fragen gestellt. Die Antworten werden bei Abschluss

der Umfrage und, nachdem der Anwender seine E-Mail-Adresse zur Verifizierung übermittelt hat,

in einer SQL-Datenbank gespeichert. Danach erhält der Anwender per E-Mail eine Bestätigung

mit einem Gutschein im Wert von 5,00 €, den er im Anschluss im Online-Shop der MuK einlösen

kann. Ein Ausschnitt davon befindet sich im Anhang A.14: Feedback Dialog (Ausschnitt).

Die Funktion zur Prüfung und Speicherung der E-Mail-Adresse des Benutzers befindet sich

ebenfalls im Anhang A.15: E-Mailadressen auf Duplikate prüfen und speichern.

Der Bot beinhaltet kleinere Funktionen, um auf belanglose Nachrichten, Beleidigungen oder

Supportanfragen eingehen zu können. Bei einer Supportanfrage werden die Kontaktinformationen

des Kunden und seine Anfrage an einen Mitarbeiter der Service-Abteilung weitergeleitet. Bei

belanglosen Nachrichten und Beleidigungen wird eine entsprechende Antwort ausgegeben.


Jim Eidmann 14

6. Abnahme- und Einführungsphase

6.1 Abnahme durch die Service-Abteilung

Nachdem die Anwendung fertig entwickelt war, wurde sie, wie nach jeder Iterationsphase bereits

erfolgt, der Service-Abteilung zur Abnahme vorgelegt. Da sowohl die Funktionalitäten, als auch

der Umgang mit dem Chat-Bot durch die bereits durchlaufenen Iterationen und Tests bekannt war,

lief die Endabnahme problemlos. Vor der finalen Veröffentlichung im Webshop der MuK, wurde

ein Code-Review zur Qualitätssicherung durchgeführt.

6.2 Veröffentlichung und Einführung

Aufgrund der Cloud-Architektur und der Tatsache, dass es sich hierbei nicht um eine Desktop-

bzw. Client-Software handelt, gestaltete sich die Veröffentlichung als unkompliziert. Zuerst wurde

der eigentliche Chat-Bot in Microsoft Azure eingerichtet und öffentlich zugänglich gemacht.

Danach musste im Webshop der MuK der Bot per iFrame hinterlegt werden.

Anschließend wurde in Microsoft Azure die Funktionalität „Application Insights“ aktiviert und

eingerichtet, um Kunden-Anfragen statistisch auswerten zu können.

6.3 Dokumentation

Die Dokumentation des Chat-Bots setzt sich aus dem Benutzerhandbuch und der

Projektdokumentation zusammen, die beide vom Autor manuell erstellt wurden.

Das Benutzerhandbuch besteht aus jeweils einer Anleitung für die Services LUIS und QnA-Maker,

damit die Mitarbeiter der Service-Abteilung, unabhängig vom Entwickler, neue FAQs und

Äußerungen hinzufügen können. Ein Ausschnitt davon befindet sich im Anhang A.16:

Benutzerhandbuch (Ausschnitt). In der Projektdokumentation werden die einzelnen Projektphasen

und entsprechenden Vorgänge des Projekts näher erläutert.


Jim Eidmann 15

7. Fazit

7.1 Soll/ Ist-Vergleich

Rückblickend betrachtet wurden alle im Pflichtenheft definierten Anforderungen umgesetzt. Der

zu Anfang erstellte Projektplan konnte ebenfalls eingehalten werden. In der Tabelle Soll/ Ist-

Vergleich ist der benötigte Zeitaufwand gegenübergestellt. Es ist zu erkennen, dass es eine gewisse

Zeitdifferenz bei der Entwicklung und der Systemintegration gegeben hat. Da die Entwicklung des

Chat-Bots weniger Zeit benötigte, konnten die verbleibenden zwei Stunden für Tests verwendet

werden. Somit wurde das Projekt in den festgelegten 70 Stunden umgesetzt.

Projektphase Soll Ist Differenz

Anforderungsdefinition 14 Std. 14 Std. 0 Std.

Konzeption und

Entwicklung

42 Std. 40 Std. -2 Std.

Systemintegration und

Tests

14 Std. 16 Std. +2 Std.

Gesamt 70 Std. 70 Std. 0 Std.

Tabelle 5: Soll/ Ist-Vergleich

7.2 Gewonnene Erkenntnisse

Im Laufe des Projektes konnte der Autor viele Dinge im Bereich Projektmanagement, Language

Understanding und agiler Softwareentwicklung lernen, aber auch neue Erfahrungen im Bereich

C#, Chat-Bots und Microsoft Azure sammeln. Besonders die hinzugewonnenen Kenntnisse im

Microsoft Bot Framework werden auch weiterhin sehr nützlich sein. Somit war das Projekt nicht

nur für die Service-Abteilung der MuK eine Entlastung, sondern auch für den Autor eine

Bereicherung seiner Fähigkeiten und Kenntnisse.

7.3 Ausblick

Aufgrund der vielen Möglichkeiten, gibt es bereits Ideen und Anforderungen, die in Zukunft noch

umgesetzt werden können. Dazu zählt, zum Beispiel, die Möglichkeit, als Kunde, den Status seiner

Bestellung anfragen zu können oder direkt über den Chat-Bot im Webshop zu bestellen. Durch

den modularen Aufbau der Software, können jederzeit neue Funktionen hinzugefügt und

veröffentlicht werden. Da sich die Anforderungen an den Chat-Bot in unregelmäßigen Abständen

ändern können, werden die Services generell erweitert werden müssen. Dies kann, dank dem

Benutzerhandbuch, von den Mitarbeitern der Service-Abteilung selber erledigt werden.


Jim Eidmann V

A. Anhang

A.1 Detaillierte Zeitplanung

Anforderungsdefinition 14 Std.

1. Ist-Analyse 7 Std.

2. Wirtschaftlichkeitsanalyse 2 Std.

3. Erstellung des Lastenheftes

(mit Auftraggeber)

5 Std.

Konzeption und Entwicklung 42 Std.

1. Zielplattform definieren 0,5 Std.

2. Datenbank entwerfen 1 Std.

3. Konversationslogik (Theorie)

erstellen

3 Std.

4. Pflichtenheft erstellen 5 Std.

5. Iterationsplanung 0,5 Std.

6. Datenbank implementieren 1 Std.

7. Entwicklungsumgebung einrichten 2 Std.

8. Services implementieren 5 Std.

9. Konversationslogik implementieren 10 Std.

10. Entwicklerdokumentation erstellen 2 Std.

11. Benutzerhandbuch erstellen 2 Std.

12. Projektdokumentation erstellen 10 Std.

Systemintegration und Tests 14 Std.

1. Veröffentlichung in Azure 2 Std.

2. Einrichten von Application Insights 2 Std.

3. Abschlusstest durch unabhängige

Testpersonen und ggf. Verbesserung

der Konversationslogik

10 Std.

Tabelle 6: Detaillierte Zeitplanung


Jim Eidmann VI

A.2 Verwendete Ressourcen

Hardware

• Büroarbeitsplatz mit Notebook, Dockingstation und externem Monitor

Software

• Windows 10 Enterprise - Betriebssystem

• Visual Studio Professional 2017 – IDE für .Net-Sprachen

• Microsoft Bot Framework – Framework zur Entwicklung von Bots

• Microsoft SQL Server – Datenbank

• Microsoft Azure – Cloudlösung

• Microsoft SQL Server Management Studio 17.4 – Verwaltung für MSSQL-

Datenbanken

• Microsoft Bot Emulator – Testen von Bots

• LUIS – Language Understanding Intelligent Service

• QnA-Maker – Service von Microsoft zur Beantwortung von Fragen

• Dia Diagram Editor – Open Source Software zur Erstellung von Diagrammen

• MySQL Workbench – Datenbankverwaltung (Wurde zur Erstellung des

Tabellenmodells genutzt)

• Trello – Projektmanagementsoftware

• Shopware 5.4.2 – modulares Online-Shopsystem

• Git - Versionsverwaltung

• Microsoft Word – Textverarbeitungssoftware zur Erstellung der Projektdokumentation

Personal

• Mitarbeiter der Service-Abteilung

• Entwickler – Projektumsetzung

• Anwendungsentwickler – Code-Review

• Unabhängige Tester – Finaler Test der Konversationslogik


Jim Eidmann VII

A.3 Trello – Kanban-Board

Abbildung 2: Trello

A.4 Auszug Lastenheft zur Erstellung eines Chat-Bots

Die Anforderungen werden im Folgenden mithilfe von User Storys dargestellt.

3.1 User Story 1

Nr. / ID US_01 Nichttechnischer Titel Fragen des Kunden

Quelle Webshop-Kunde Verweise Priorität Hoch

Beschreibung

Als Webshop-Kunde möchte ich Fragen stellen können, damit ich den sehr speziellen Ablauf

der Wäscherei besser verstehen kann.

Voraussetzung

- Service-Bot muss in Shopware eingebunden sein

- QnA-Maker muss im Service-Bot eingebunden sein

- Fragen des Kunden müssen zu dem FAQ der Wäscherei passen (Fragen wie: „Wie ist

das Wetter heute“ kann der Bot nicht beantworten)


Jim Eidmann VIII

Auslöser

- Kunde schickt, entweder über die Chatfunktion im Shopsystem oder über Social Media

(Facebook Messenger, Telegram, Skype) eine Frage an den Bot

Grobschätzung des Aufwands

- Einbindung von QnA-Maker

- Anpassung des FAQ

- Aufwand ca. 6 Stunden

3.2 User Story 2

Nr. / ID US_02 Nichttechnischer Titel Feedback des Kunden

Quelle Webshop-Kunde Verweise Priorität Mittel

Beschreibung

Als Webshop-Kunde möchte ich Feedback geben können, damit sich der Service zu meinen

Gunsten verbessern kann.

Voraussetzung

- Service-Bot muss in Shopware eingebunden sein

- LUIS muss mit dem Service-Bot verknüpft sein

- Feedback muss per E-Mail an zuständigen Mitarbeiter geschickt werden können

Auslöser

- Der Kunde wählt im Dialog mit dem Bot die Option für die Bewertung aus

Grobschätzung des Aufwands

- Programmierung (Implementierung von Dialogen)

- Einbindung von LUIS

- Aufwand ca. 10 Stunden


Jim Eidmann IX

A.5 Entity-Relationship-Modell

Abbildung 3: Entity-Relationship-Modell

A.6 Tabellenmodell

Abbildung 4: Tabellenmodell


Jim Eidmann X

A.7 Auszug Pflichtenheft zur Entwicklung eines Chatbots

Zielbestimmungen

Musskriterien

Kundenanfragen

▪ Fragen zur Wäscherei

▪ Fragen zum Wasch- und Imprägnierungsverfahren

▪ Fragen zu bestimmten Produkten

▪ Kontaktaufnahme

▪ Fragen zum Ablauf

▪ Fragen zum Sendungsstatus

• Feedback

▪ Statische Bewertungsfragen

▪ Auswahl durch Benutzer (1. Sehr gut, etc.)

▪ Ergebnis an Mitarbeiter

▪ Manuell erstellter Gutschein an Kunden

• Information an Mitarbeiter senden

▪ Konversation per E-Mail an Mitarbeiter senden

Wunschkriterien

• Auswertung / Statistik

▪ Application Insights

Abgrenzungskriterien

• Keine direkte Schnittstelle zu Shopware

Produkteinsatz

Das Produkt dient zur automatisierten Bearbeitung von Kundenanfragen, der Möglichkeit

für den Kunden Feedback zu hinterlassen und der Bereitstellung bereits vorhandener

Konversationen, damit der Mitarbeiter individuell auf die Anfragen eingehen kann, die der

Bot nicht lösen konnte.

Zielgruppe des Produktes sind vor allem Privatkunden, die im Online-Shop der Wäscherei

bestellen. Aber auch interessierte Parteien, bzw. Geschäftskunden mit individuellen

Verträgen können Anfragen stellen.

Anwendungsbereiche

Der Anwendungsbereich umfasst sämtliche Shop-Kunden (Privat oder Geschäftlich) und

alle, die Interesse an einer umweltfreundlichen Imprägnierung Ihrer Textilie haben.

Außerdem besteht die Möglichkeit mit Hilfe der Feedback-Funktionalität einen Gutschein

für den Online-Shop zu erhalten.


Jim Eidmann XI

Zielgruppen

Die Zielgruppen umfassen alle Privat- und Geschäftskunden der MeyerundKuhl

Spezialwäschen GmbH. Dabei ist es nicht relevant, ob es sich um Erstkunden,

Stammkunden oder Interessenten handelt.

Betriebsbedingungen

Die Betriebsbedingungen müssen für die Anwendung in Microsoft Azure und im Online-

Shop spezifiziert werden. Die maximale Anzahl der Benutzer ist prinzipiell unbeschränkt.

Der Zugang zum Programm steht täglich 24 Stunden lang zur Verfügung, sofern der

Server/Azure dies zulassen.

A.8 Iterationsplan zur Entwicklung eines Chat-Bots

• Erstellung der Datenbank

• Implementierung der Konversationslogik mittels LUIS-Service

• Implementierung der Fragen-/Antwortlogik mittels QnA-Maker

• Implementierung der Feedback-Logik

• Implementierung der Benachrichtigungsfunktion (E-Mail)

• Veröffentlichung in Microsoft Azure

• Application Insights in Azure einrichten

A.9 LUIS Klassen

public class LUIS

{

public string query { get; set; }

public Intent[] intents { get; set; }

public Entity[] entities { get; set; }

}

public class Rootobject

{

public string query { get; set; }

public Topscoringintent topScoringIntent { get; set; }

public Intent[] intents { get; set; }

public Entity[] entities { get; set; }

}


Jim Eidmann XII

public class Topscoringintent

{

public string intent { get; set; }

public float score { get; set; }

}

public class Intent

{

public string intent { get; set; }


}

public class Entity

{

public string entity { get; set; }

public string type { get; set; }

public int startIndex { get; set; }

public int endIndex { get; set; }


}


Jim Eidmann XIII

A.10 LUIS Entity abfragen

private static async Task<Luis> GetEntityFromLuis(string Query)

{

// Kodierung der Abfrage (Abfrage = Nachricht des Users)

Query = Uri.EscapeDataString(Query);

// Neue Luis Klasse erstellen

Luis Data = new Luis();

using (HttpClient client = new HttpClient())

{

// Abfrage-URI mit Subscription Key und Abfrage definieren

string RequestURI =

"https://westus.api.cognitive.microsoft.com/luis/v2.0/apps/2e145369-f8e9-4238-86de-

8b6f7871182b?subscription-

key=c92c7d6d010f419bb6c76fc23a4be53f&verbose=true&timezoneOffset=0&q="+ Query;

HttpResponseMessage msg = await client.GetAsync(RequestURI);

// Wenn die Abfrage erfolgreich war

if (msg.IsSuccessStatusCode)

{

// Antwort von Luis-Service

var JsonDataResponse = await msg.Content.ReadAsStringAsync();

// Antwort von JSON zu .NET-Objekt konvertieren

Data = JsonConvert.DeserializeObject<Luis>(JsonDataResponse);

}

}

// Rückgabe der Antwort als .Net-Objekt

return Data;


Jim Eidmann XIV

A.11 JSON Beispiel

{

"query": "wascht ihr auch Schlafsäcke?",

"topScoringIntent": {

"intent": "Question",

"score": 0.9445568

},

"intents": [

{

"intent": "Question",

"score": 0.9445568

},

{

"intent": "price",

"score": 0.0181183256

},

{

"intent": "Offense",

"score": 0.0128170755

},

{

"intent": "Superficial",

"score": 0.009286328

},

{

"intent": "Help",

"score": 0.007988564

},

{

"intent": "Feedback",

"score": 0.00762051623

},

[…]


Jim Eidmann XV

A.12 Root Dialog (Ausschnitt)

public class RootDialog : IDialog<object>

{

public async Task StartAsync(IDialogContext context)

{

// Nachricht empfangen - Art der Nachricht bestimmen

context.Wait(MessageReceivedOperationChoice);

}

public async Task MessageReceivedOperationChoice(IDialogContext context,

IAwaitable<IMessageActivity> argument)

{

// Die Nachricht vom User

var message = await argument;

if (message.Type == ActivityTypes.Message)

{

Luis FeLuis = await GetEntityFromLuis(message.Text);

if (FeLuis.intents.Count()>0)

{

switch(FeLuis.intents[0].intent)

{

case "Welcome":

await context.PostAsync(message.Text);

// Frage, was der User tun will

await context.PostAsync($"Sie können entweder eine Frage stellen oder eine

kurze Feedback-Umfrage ausfüllen, die mit einem 5€ Gutschein belohnt wird.");

await context.PostAsync($"Was wollen Sie tun?");

break;

// Wenn der User Feedback geben will

case "Feedback":

// Feedback-Dialog aufrufen

await context.Forward(new FeedbackDialog(),

ResumeAfterFeedbackDialog, message, CancellationToken.None);


Jim Eidmann XVI

break;

// Wenn der Kunde eine Frage stellt

case "Question":

// Fragen-Dialog aufrufen

Await context.Forward(new QnaDialog(), ResumeAfterQnaDialog, message,

CancellationToken.None);

break;

[…]

A.13 QnA-Maker Dialog (Ausschnitt)

public override async Task DefaultMatchHandler(IDialogContext context, string

originalQueryText, QnAMakerResult result)

{

// Wenn Funktion aus dem Kontext heraus aufgerufen wird (z.B. Bot: Wollen Sie mehr

erfahren? User: Ja.")

if (

originalQueryText.ToLower().Contains("ja") ||

originalQueryText.ToLower().Contains("frage") ||

originalQueryText.ToLower().Contains("fragen"))

{

// Antwort entsprechend als Frage

await context.PostAsync($"Wie lautet Ihre Frage?");

}

else

{

var messageActivity = ProcessResultAndCreateMessageActivity(context, ref result);

string response;

messageActivity.Text = result.Answers.First().Answer;

response = messageActivity.Text;

if (response == "exit")

{

// Nichts tun, Nachricht an User geht über Root-Dialog

}


Jim Eidmann XVII

else

{

context.Done(response);

}

}

}

public override async Task NoMatchHandler(IDialogContext context, string

originalQueryText)

{

// Wenn Funktion aus dem Kontext heraus aufgerufen wird (z.B. Bot: Wollen Sie mehr

erfahren? User: Ja."

if (

originalQueryText.ToLower().Contains("ja") ||

originalQueryText.ToLower().Contains("frage") ||

originalQueryText.ToLower().Contains("fragen"))

{

// Antwort entsprechend als Frage

await context.PostAsync($"Wie lautet Ihre Frage?");

}

else

{

// Antwort des Bots angepasst, sagt normalerweise etwas anderes

await context.PostAsync($"Ich verstehe die Frage nicht. Könnte ich mehr

Informationen haben?");

}

}

[…]

A.14 Feedback Dialog (Ausschnitt)

public async Task MessageReceivedStart(IDialogContext context,


{



Jim Eidmann XVIII


// z.B. User: Kann man euch bewerten?

if (message.Text.Contains("?"))

{

await context.PostAsync("Ja, natürlich.");

}

// Ausgabe

await context.PostAsync("Umfrage beginnt... Bitte beachten Sie, dass Sie die Umfrage

nur einmal durchführen können.");

await context.PostAsync("Wie zufrieden sind Sie mit uns generell?");

// Springt wieder zur Auswahl, was der User tun möchte


}

public async Task MessageReceivedOperationChoice(IDialogContext context,


{



// Klasse Luis aufrufen und entsprechenden Entity auslesen


// Entity gefunden

if (FeLuis.intents.Count() > 0)

{

// Auswahl des entsprechenden Falls

switch (FeLuis.intents[0].intent)

{


Jim Eidmann XIX

// Positives Feedback

case "GoodFeedback":

await context.PostAsync("Das freut mich zu hören! Was hat Ihnen denn

besonders gut gefallen?");

context.Wait(ReceivedMessageGoodFeedback);

break;

// Negatives Feedback

case "BadFeedback":

await context.PostAsync("Das tut mir leid! Was hat Ihnen denn nicht

gefallen?");

context.Wait(ReceivedMessageBadFeedback);

break;

// Kein Feedback (z.B. "Keine Ahnung")

case "NoFeedback":

await context.PostAsync("Das klingt als hätten Sie noch nie bei uns bestellt.

Haben Sie Fragen?");

context.Wait(MessageReceivedNoFeedback);

break;

// Wenn der Bot den User nicht versteht

default:

await context.PostAsync("Wie bitte?");


break;

}

}

else

{




}

}


Jim Eidmann XX

public async Task ReceivedMessageGoodFeedback(IDialogContext context,


{



// Klasse Luis aufrufen und entsprechenden Entity auslesen


// Entity gefunden

if (FeLuis.intents.Count() > 0)

{

// Auswahl des entsprechenden Falls

switch (FeLuis.intents[0].intent)

{

// Guter Ablauf

case "procedure":

await context.PostAsync("Haben Sie bezüglich des Ablaufs noch irgendwelche

Fragen oder Wünsche?");

context.Wait(MessageReceivedFinish);

break;

// Gute Imprägnierung

case "impregnation":

await context.PostAsync("Haben Sie bezüglich der Imprägnierung noch Fragen

oder Wünsche?");


break;

// Guter Preis // Preis-Leistungsverhältnis

case "price":

await context.PostAsync("Haben Sie bezüglich des Preises noch irgendwelche

Fragen oder Wünsche?");


break;


Jim Eidmann XXI

case "NoFeedback":

await context.PostAsync("In Ordnung, haben Sie trotzdem vielen Dank!");


break;

default:

// Nachricht nicht verstanden


break;

}

}

else

{




}

}


Jim Eidmann XXII

A.15 E-Mailadressen auf Duplikate prüfen und speichern

public async Task saveMail(IDialogContext context, IAwaitable<IMessageActivity>

argument)

{

try

{

// Nachricht vom User

var userMessage = await argument as Activity;

// Text der Nachricht

string mail = userMessage.Text;

// Variablen für SQL-Verbindung

string sqlCon = null;

string sql = null;

// Zugangsdaten

sqlCon = "user id=sa;" +

"password=sa;server=NOTEBOOKJK00X\\SQLEXPRESS;" +

"Trusted_Connection=yes;" +

"database=BotData; " +

"connection timeout=30";

// Erstellen der SQL-Verbindung

using (SqlConnection cnn = new SqlConnection(sqlCon))

{

// Anzahl an Einträgen mit dieser E-Mail Adresse zählen

sql = "SELECT COUNT(KundeMail) FROM Kunde WHERE Kunde

Mail=@mail";

// Öffnen der SQL-Verbindung

cnn.Open();


Jim Eidmann XXIII

// Erstellen des SQL-Commands

using (SqlCommand cmd = new SqlCommand(sql, cnn))

{

// Variable mail als Parameter hinzufügen

cmd.Parameters.AddWithValue("@mail", mail);

// Abfrage ausführen

cmd.ExecuteNonQuery();

// Anzahl an Einträgen mit der E-Mail Adresse auslesen

int count = Convert.ToInt32(cmd.ExecuteScalar());

// Wenn 0 / noch nicht vorhanden

if (count == 0)

{

// Einfügen der E-Mail

sql = "INSERT INTO Kunde (KundeMail) Values (@mail);";

using (SqlCommand cmd2 = new SqlCommand(sql, cnn))

{

cmd2.Parameters.AddWithValue("@mail", mail);

cmd2.ExecuteNonQuery();

}

}

else

{

// Falls die E-Mail Adresse bereits existiert

context.Done("Du scheinst schon teilgenommen zu haben. Was möchtest du

tun?");

}

}

}


Jim Eidmann XXIV

A.16 Ausschnitt Benutzerhandbuch

1. Neue Fragen / Antworten im QnA-Maker hinzufügen

Um neue Fragen / Antworten zum FAQ hinzufügen zu können, muss sich erst auf der offiziellen

Website des QnA-Makers eingeloggt werden.

URL: https://qnamaker.ai

Unter der Kategorie „My services“, in der oberen Menüleiste, kann man sich eine Übersicht

aller bereits erstellten Services anschauen.

Zum Bearbeiten eines Service muss auf das Stift-Symbol auf der rechten Seite geklickt werden.

In dem Bereich „Knowledge Base“ befinden sich die bereits erstellten FAQs. Falls noch keine

FAQs erstellt/hochgeladen wurden, ist diese leer.

Um ein neues FAQ hinzuzufügen, muss man in den Bereich „Settings“ gehen. Dort gibt es die

Möglichkeit, eine Website oder ein PDF zu hinterlegen. Nachdem das erledigt ist, kann der

Service mittels „Save and retrain“-Button trainiert werden. Anschließend wird er im Bereich

„Test“ auf seine Funktionalität geprüft.

Wenn alle Fragen korrekt beantwortet wurden, kann er mittels „Publish“-Button veröffentlicht

werden.

Alternativ besteht die Möglichkeit, in der „Knowledge Base“, einzelne Fragen- und

Antworttexte zu verändern.

[…]

https://qnamaker.ai/

Dokumentation zur betrieblichen Projektarbeit...Abschlussprüfung Sommer 2018 Fachinformatiker für...

Documents

Transcript of Dokumentation zur betrieblichen Projektarbeit...Abschlussprüfung Sommer 2018 Fachinformatiker für...