Das Hauptziel bei der Erstellung eines Bots besteht darin, mit dem Benutzer eine aussagekräftige Konversation zu führen. Dieses Ziel erreichen Sie am besten, indem Sie Folgendes sicherstellen: Gleich nach dem ersten Anmelden müssen Benutzer den Hauptzweck und die Funktionen des Bots erkennen können und sich darüber im Klaren sein, aus welchem Grund der Bot erstellt wurde. Dieser Artikel enthält Codebeispiele für die Begrüßung von Benutzern in Ihrem Bot.
Hinweis
Die JavaScript-, C#- und Python-SDKs für Bot Framework werden weiterhin unterstützt, das Java-SDK wird jedoch eingestellt und der langfristige Support endet im November 2023.
Bestehende Bots, die mit dem Java SDK erstellt wurden, werden weiterhin funktionieren.
Eine Kopie des Beispiels zur Benutzerbegrüßung im C#-Beispiel, JS-Beispiel, Java-Beispiel oder Python-Beispiel. Der Code aus dem Beispiel wird verwendet, um zu beschreiben, wie Sie Begrüßungsnachrichten senden.
Informationen zu diesem Beispielcode
Dieser Beispielcode veranschaulicht, wie Sie neue Benutzer erkennen und begrüßen, wenn diese zum ersten Mal eine Verbindung mit Ihrem Bot herstellen. Im folgenden Diagramm ist der Logikfluss für diesen Bot dargestellt.
Die beiden wichtigsten Ereignisse für den Bot sind:
OnMembersAddedAsync, die aufgerufen wird, wenn sich ein neuer Benutzer mit Ihrem Bot verbindet.
OnMessageActivityAsync, die aufgerufen wird, wenn Ihr Bot neue Benutzereingaben erhält.
Wenn eine Verbindung mit einem neuen Benutzer hergestellt wird, werden vom Bot die Elemente WelcomeMessage, InfoMessage und PatternMessage bereitgestellt.
Wenn eine neue Benutzereingabe empfangen wird, wird WelcomeUserState darauf überprüft, ob DidBotWelcomeUser auf true festgelegt ist. Wenn dies nicht der Fall ist, wird für den Benutzer die Nachricht für die erstmalige Begrüßung zurückgegeben.
Die beiden wichtigsten Ereignisse für den Bot sind:
onMembersAdded, die aufgerufen wird, wenn sich ein neuer Benutzer mit Ihrem Bot verbindet.
onMessage, die aufgerufen wird, wenn Ihr Bot neue Benutzereingaben erhält.
Wenn eine Verbindung mit einem neuen Benutzer hergestellt wird, werden vom Bot die Elemente welcomeMessage, infoMessage und patternMessage bereitgestellt.
Wenn eine neue Benutzereingabe empfangen wird, wird welcomedUserProperty darauf überprüft, ob didBotWelcomeUser auf true festgelegt ist. Wenn dies nicht der Fall ist, wird für den Benutzer die Nachricht für die erstmalige Begrüßung zurückgegeben.
Wenn DidBotWelcomeUser auf true festgelegt ist, wird die Eingabe des Benutzers ausgewertet. Basierend auf dem Inhalt der Eingabe des Benutzers führt der Bot einen der folgenden Schritte aus:
Zurückgeben der vom Benutzer erhaltenen Begrüßung
Anzeigen einer Hero Card mit zusätzlichen Informationen zu Bots
Erneutes Senden von WelcomeMessage mit einer Beschreibung der Eingaben, die für diesen Bot erwartet werden
Die beiden wichtigsten Ereignisse für den Bot sind:
onMembersAdded, die aufgerufen wird, wenn sich ein neuer Benutzer mit Ihrem Bot verbindet.
onMessageActivity, die aufgerufen wird, wenn Ihr Bot neue Benutzereingaben erhält.
Wenn eine Verbindung mit einem neuen Benutzer hergestellt wird, werden vom Bot die Elemente WELCOME_MESSAGE, INFO_MESSAGE und PATTERN_MESSAGE bereitgestellt.
Wenn eine neue Benutzereingabe empfangen wird, wird WelcomeUserState darauf überprüft, ob getDidBotWelcomeUser() auf true festgelegt ist. Wenn dies nicht der Fall ist, wird für den Benutzer die Nachricht für die erstmalige Begrüßung zurückgegeben.
Die beiden wichtigsten Ereignisse für den Bot sind:
on_members_added_activity, die aufgerufen wird, wenn sich ein neuer Benutzer mit Ihrem Bot verbindet.
on_message_activity, die aufgerufen wird, wenn Ihr Bot neue Benutzereingaben erhält.
Bei jedem Verbinden mit einem neuen Benutzer wird für diesen vom Bot eine Begrüßungsnachricht, eine Informationsnachricht und eine Musternachricht bereitgestellt.
Wenn eine neue Benutzereingabe empfangen wird, wird die welcome_user_state.did_welcome_user-Eigenschaft überprüft. Wenn sie nicht auf true festgelegt ist, wird an den Benutzer die anfängliche Begrüßungsnachricht zurückgegeben. Wenn sie auf true festgelegt ist, führt der Bot basierend auf dem Inhalt der Eingabe des Benutzers einen der folgenden Schritte aus:
Zurückgeben der vom Benutzer erhaltenen Begrüßung
Anzeigen einer Hero Card mit zusätzlichen Informationen zu Bots
Das Benutzerzustandsobjekt wird beim Start erstellt, und die Abhängigkeit wird in den Botkonstruktor eingefügt.
Startup.cs
// Create the Bot Framework Authentication to be used with the Bot Adapter.
services.AddSingleton<BotFrameworkAuthentication, ConfigurationBotFrameworkAuthentication>();
// Create the Bot Adapter with error handling enabled.
Bots\WelcomeUserBot.cs
// Initializes a new instance of the "WelcomeUserBot" class.
public WelcomeUserBot(UserState userState)
{
_userState = userState;
}
Beim Start wird der Benutzerzustand in index.js definiert und vom Botkonstruktor verwendet.
index.js
// Create HTTP server
const server = restify.createServer();
server.use(restify.plugins.bodyParser());
server.listen(process.env.port || process.env.PORT || 3978, function() {
console.log(`\n${ server.name } listening to ${ server.url }`);
console.log('\nGet Bot Framework Emulator: https://aka.ms/botframework-emulator');
Das Benutzerzustandsobjekt wird beim Start erstellt und die Abhängigkeit wird vom Spring-Container in den Bot-Konstruktor injiziert.
Application.java
@Bean
public Bot getBot(UserState userState) {
return new WelcomeUserBot(userState);
}
WelcomeUserBot.java
private final UserState userState;
// Initializes a new instance of the "WelcomeUserBot" class.
@Autowired
public WelcomeUserBot(UserState withUserState) {
userState = withUserState;
}
Beim Start wird der Benutzerzustand in app.py definiert und vom Botkonstruktor verwendet.
app.py
# Create the Bot
BOT = WelcomeUserBot(USER_STATE)
# Listen for incoming requests on /api/messages.
Jetzt erstellen wir einen Eigenschaftenaccessor, der uns ein Handle für WelcomeUserState innerhalb der OnMessageActivityAsync-Methode bereitstellt.
Anschließend rufen wir die GetAsync-Methode auf, um den Schlüssel mit dem korrekten Gültigkeitsbereich zu erhalten. Wir speichern die Daten zum Benutzerzustand dann nach jedem Benutzereingaben-Durchlauf, indem wir die SaveChangesAsync-Methode verwenden.
Bots\WelcomeUserState.cs
// Gets or sets whether the user has been welcomed in the conversation.
public bool DidBotWelcomeUser { get; set; } = false;
Bots\WelcomeUserBot.cs
var didBotWelcomeUser = await welcomeUserStateAccessor.GetAsync(turnContext, () => new WelcomeUserState(), cancellationToken);
Wir erstellen nun einen Eigenschaftenaccessor, über den wir einen Handle für das welcomedUserProperty-Element erhalten, das unter userState dauerhaft gespeichert wird.
this.onMessage(async (context, next) => {
// Read UserState. If the 'DidBotWelcomedUser' does not exist (first time ever for a user)
// set the default to false.
const didBotWelcomedUser = await this.welcomedUserProperty.get(context, false);
/**
* Override the ActivityHandler.run() method to save state changes after the bot logic completes.
*/
async run(context) {
await super.run(context);
// Save state changes
await this.userState.saveChanges(context);
}
Jetzt erstellen wir einen Eigenschaftenaccessor, der uns ein Handle für WelcomeUserState innerhalb der onMessageActivity-Methode bereitstellt.
Anschließend rufen wir die get-Methode auf, um den Schlüssel mit dem korrekten Gültigkeitsbereich zu erhalten. Wir speichern die Daten zum Benutzerzustand dann nach jedem Benutzereingaben-Durchlauf, indem wir die saveChanges-Methode verwenden.
WelcomeUserBot.java
// Get state data from UserState.
StatePropertyAccessor<WelcomeUserState> stateAccessor =
userState.createProperty("WelcomeUserState");
CompletableFuture<WelcomeUserState> stateFuture =
stateAccessor.get(turnContext, WelcomeUserState::new);
Er verwendet den Eigenschaftenaccessor im Handler on_message_activity und überschreibt den Handler on_turn, um den Zustand vor dem Ende des Turns zu speichern.
# Get the state properties from the turn context.
welcome_user_state = await self.user_state_accessor.get(
turn_context, WelcomeUserState
)
async def on_turn(self, turn_context: TurnContext):
await super().on_turn(turn_context)
# save changes to WelcomeUserState after each turn
await self._user_state.save_changes(turn_context)
Erkennen und Begrüßen von erstmals verbundenen Benutzern
In WelcomeUserBot führen wir mit OnMembersAddedAsync() eine Überprüfung auf ein Aktivitätsupdate durch, um zu ermitteln, ob der Konversation ein neuer Benutzer hinzugefügt wurde. An diesen Benutzer senden wir dann die drei anfänglichen Begrüßungsnachrichten WelcomeMessage, InfoMessage und PatternMessage. Der vollständige Code für diese Interaktion ist unten angegeben.
Bots\WelcomeUserBot.cs
public class WelcomeUserBot : ActivityHandler
{
// Messages sent to the user.
private const string WelcomeMessage = "This is a simple Welcome Bot sample. This bot will introduce you " +
"to welcoming and greeting users. You can say 'intro' to see the " +
"introduction card. If you are running this bot in the Bot Framework " +
"Emulator, press the 'Start Over' button to simulate user joining " +
"a bot or a channel";
private const string InfoMessage = "You are seeing this message because the bot received at least one " +
"'ConversationUpdate' event, indicating you (and possibly others) " +
"joined the conversation. If you are using the emulator, pressing " +
"the 'Start Over' button to trigger this event again. The specifics " +
"of the 'ConversationUpdate' event depends on the channel. You can " +
"read more information at: " +
"https://aka.ms/about-botframework-welcome-user";
private const string LocaleMessage = "You can use the activity's 'GetLocale()' method to welcome the user " +
"using the locale received from the channel. " +
"If you are using the Emulator, you can set this value in Settings.";
{
foreach (var member in membersAdded)
{
if (member.Id != turnContext.Activity.Recipient.Id)
{
await turnContext.SendActivityAsync($"Hi there - {member.Name}. {WelcomeMessage}", cancellationToken: cancellationToken);
await turnContext.SendActivityAsync(InfoMessage, cancellationToken: cancellationToken);
await turnContext.SendActivityAsync($"{LocaleMessage} Current locale is '{turnContext.Activity.GetLocale()}'.", cancellationToken: cancellationToken);
await turnContext.SendActivityAsync(PatternMessage, cancellationToken: cancellationToken);
}
}
}
Mit diesem JavaScript-Code werden anfängliche Begrüßungsnachrichten gesendet, wenn ein Benutzer hinzugefügt wird. Hierfür wird die Konversationsaktivität überprüft und sichergestellt, dass der Konversation ein neues Mitglied hinzugefügt wurde.
bots/welcomeBot.js
// Sends welcome messages to conversation members when they join the conversation.
// Messages are only sent to conversation members who aren't the bot.
this.onMembersAdded(async (context, next) => {
// Iterate over all new members added to the conversation
for (const idx in context.activity.membersAdded) {
// Greet anyone that was not the target (recipient) of this message.
// Since the bot is the recipient for events from the channel,
// context.activity.membersAdded === context.activity.recipient.Id indicates the
// bot was added to the conversation, and the opposite indicates this is a user.
if (context.activity.membersAdded[idx].id !== context.activity.recipient.id) {
await context.sendActivity(`Welcome to the 'Welcome User' Bot. This bot will introduce you to welcoming and greeting users.`);
await context.sendActivity(`You are seeing this message because the bot received at least one 'ConversationUpdate' ` +
`event, indicating you (and possibly others) joined the conversation. If you are using the emulator, ` +
`pressing the 'Start Over' button to trigger this event again. The specifics of the 'ConversationUpdate' ` +
`event depends on the channel. You can read more information at https://aka.ms/about-botframework-welcome-user`);
await context.sendActivity(`You can use the activity's 'locale' property to welcome the user ` +
`using the locale received from the channel. ` +
`If you are using the Emulator, you can set this value in Settings. ` +
`Current locale is '${ context.activity.locale }'`);
await context.sendActivity(`It is a good pattern to use this event to send general greeting to user, explaining what your bot can do. ` +
`In this example, the bot handles 'hello', 'hi', 'help' and 'intro'. ` +
`Try it now, type 'hi'`);
}
}
// By calling next() you ensure that the next BotHandler is run.
await next();
});
In WelcomeUserBot führen wir mit onMembersAdded() eine Überprüfung auf ein Aktivitätsupdate durch, um zu ermitteln, ob der Konversation ein neuer Benutzer hinzugefügt wurde. An diesen Benutzer senden wir dann die drei anfänglichen Begrüßungsnachrichten WELCOME_MESSAGE, INFO_MESSAGE und PATTERN_MESSAGE. Der vollständige Code für diese Interaktion ist unten angegeben.
WelcomeUserBot.java
public class WelcomeUserBot extends ActivityHandler {
// Messages sent to the user.
private static final String WELCOME_MESSAGE =
"This is a simple Welcome Bot sample. This bot will introduce you "
+ "to welcoming and greeting users. You can say 'intro' to see the "
+ "introduction card. If you are running this bot in the Bot Framework "
+ "Emulator, press the 'Start Over' button to simulate user joining "
+ "a bot or a channel";
private static final String INFO_MESSAGE =
"You are seeing this message because the bot received at least one "
+ "'ConversationUpdate' event, indicating you (and possibly others) "
+ "joined the conversation. If you are using the emulator, pressing "
+ "the 'Start Over' button to trigger this event again. The specifics "
+ "of the 'ConversationUpdate' event depends on the channel. You can "
+ "read more information at: " + "https://aka.ms/about-botframework-welcome-user";
private String localeMessage =
"You can use the activity's GetLocale() method to welcome the user "
+ "using the locale received from the channel. "
+ "If you are using the Emulator, you can set this value in Settings.";
private static final String PATTERN_MESSAGE =
"It is a good pattern to use this event to send general greeting"
+ "to user, explaining what your bot can do. In this example, the bot "
+ "handles 'hello', 'hi', 'help' and 'intro'. Try it now, type 'hi'";
Die on_members_added_activity überprüft, ob ein neuer Benutzer hinzugefügt wurde, und sendet dann drei anfängliche Begrüßungsnachrichten: eine Willkommensnachricht, eine Informationsnachricht und eine Musternachricht.
bots/welcome-user-bot.py
"""
Greet when users are added to the conversation.
Note that all channels do not send the conversation update activity.
If you find that this bot works in the emulator, but does not in
another channel the reason is most likely that the channel does not
send this activity.
"""
for member in members_added:
if member.id != turn_context.activity.recipient.id:
await turn_context.send_activity(
f"Hi there { member.name }. " + self.WELCOME_MESSAGE
)
await turn_context.send_activity(self.INFO_MESSAGE)
await turn_context.send_activity(
f"{ self.LOCALE_MESSAGE } Current locale is { turn_context.activity.locale }."
)
await turn_context.send_activity(self.PATTERN_MESSAGE)
Begrüßen eines neuen Benutzers und Verwerfen der ersten Eingabe
Es ist auch wichtig zu berücksichtigen, wann die Eingabe des Benutzers ggf. nützliche Informationen enthält. Dies kann je nach Kanal variieren. Um eine hohe Benutzerfreundlichkeit über alle möglichen Kanäle hinweg zu gewährleisten, wird das Statusflag didBotWelcomeUser überprüft. Ist das Ergebnis „false“, wird diese erste Benutzereingabe nicht verarbeitet. Stattdessen stellen wir für den Benutzer eine anfängliche Begrüßungsnachricht bereit. Der boolesche Wert welcomedUserProperty wird dann auf „true“ festgelegt und unter UserState gespeichert. In unserem Code wird jetzt die Eingabe dieses Benutzers aus allen zusätzlichen Nachrichtenaktivitäten verarbeitet.
Bots\WelcomeUserBot.cs
{
var welcomeUserStateAccessor = _userState.CreateProperty<WelcomeUserState>(nameof(WelcomeUserState));
var didBotWelcomeUser = await welcomeUserStateAccessor.GetAsync(turnContext, () => new WelcomeUserState(), cancellationToken);
if (didBotWelcomeUser.DidBotWelcomeUser == false)
{
didBotWelcomeUser.DidBotWelcomeUser = true;
// the channel should sends the user name in the 'From' object
var userName = turnContext.Activity.From.Name;
await turnContext.SendActivityAsync("You are seeing this message because this was your first message ever to this bot.", cancellationToken: cancellationToken);
await turnContext.SendActivityAsync($"It is a good practice to welcome the user and provide personal greeting. For example, welcome {userName}.", cancellationToken: cancellationToken);
}
else
Es ist auch wichtig zu berücksichtigen, wann die Eingabe des Benutzers ggf. nützliche Informationen enthält. Dies kann je nach Kanal variieren. Um sicherzustellen, dass für den Benutzer über alle möglichen Kanäle eine hohe Benutzerfreundlichkeit erzielt wird, überprüfen wir die didBotWelcomedUser-Eigenschaft. Wenn sie nicht vorhanden ist, legen wir „false“ fest und führen keine Verarbeitung der ersten Benutzereingabe durch. Stattdessen stellen wir für den Benutzer eine anfängliche Begrüßungsnachricht bereit. Der boolesche Wert „didBotWelcomeUser“ wird anschließend auf „true“ festgelegt, und der Code verarbeitet die Benutzereingabe aus allen zusätzlichen Nachrichtenaktivitäten.
bots/welcomeBot.js
this.onMessage(async (context, next) => {
// Read UserState. If the 'DidBotWelcomedUser' does not exist (first time ever for a user)
// set the default to false.
const didBotWelcomedUser = await this.welcomedUserProperty.get(context, false);
// Your bot should proactively send a welcome message to a personal chat the first time
// (and only the first time) a user initiates a personal chat with your bot.
if (didBotWelcomedUser === false) {
// The channel should send the user name in the 'From' object
const userName = context.activity.from.name;
await context.sendActivity('You are seeing this message because this was your first message ever sent to this bot.');
await context.sendActivity(`It is a good practice to welcome the user and provide personal greeting. For example, welcome ${ userName }.`);
// Set the flag indicating the bot handled the user's first message.
await this.welcomedUserProperty.set(context, true);
} else {
}
// By calling next() you ensure that the next BotHandler is run.
await next();
});
Es ist wichtig zu berücksichtigen, wann die Eingabe des Benutzers nützliche Informationen enthält. Dies kann je nach Kanal variieren. Um eine hohe Benutzerfreundlichkeit über alle möglichen Kanäle hinweg zu gewährleisten, wird das Statusflag getDidBotWelcomeUser überprüft. Ist das Ergebnis „false“, wird diese erste Benutzereingabe nicht verarbeitet. Stattdessen stellen wir für den Benutzer eine anfängliche Begrüßungsnachricht bereit. Der boolesche Wert setDidBotWelcomeUser wird dann auf „true“ festgelegt und unter UserState gespeichert. In unserem Code wird jetzt die Eingabe dieses Benutzers aus allen zusätzlichen Nachrichtenaktivitäten verarbeitet.
WelcomeUserBot.java
@Override
protected CompletableFuture<Void> onMessageActivity(TurnContext turnContext) {
// Get state data from UserState.
StatePropertyAccessor<WelcomeUserState> stateAccessor =
userState.createProperty("WelcomeUserState");
CompletableFuture<WelcomeUserState> stateFuture =
stateAccessor.get(turnContext, WelcomeUserState::new);
return stateFuture.thenApply(thisUserState -> {
if (!thisUserState.getDidBotWelcomeUser()) {
thisUserState.setDidBotWelcomeUser(true);
// the channel should send the user name in the 'from' object
String userName = turnContext.getActivity().getFrom().getName();
return turnContext
.sendActivities(
MessageFactory.text(FIRST_WELCOME_ONE),
MessageFactory.text(String.format(FIRST_WELCOME_TWO, userName))
);
// Save any state changes.
.thenApply(response -> userState.saveChanges(turnContext))
Es ist auch wichtig zu berücksichtigen, wann die Eingabe des Benutzers ggf. nützliche Informationen enthält. Dies kann je nach Kanal variieren. Um sicherzustellen, dass alle möglichen Kanäle dem Benutzer eine hohe Benutzerfreundlichkeit bieten, überprüft on_message_activity die did_welcome_user-Eigenschaft. Beim ersten Mal wird der Wert auf false festgelegt, und die Benutzereingabe wird nicht verarbeitet. Stattdessen wird für den Benutzer eine anfängliche Begrüßungsnachricht bereitgestellt. Anschließend wird did_welcome_user auf true festgelegt, und die Benutzereingaben von allen zusätzlichen Nachrichtenaktivitäten werden verarbeitet.
bots/welcome-user-bot.py
if not welcome_user_state.did_welcome_user:
welcome_user_state.did_welcome_user = True
await turn_context.send_activity(
"You are seeing this message because this was your first message ever to this bot."
)
name = turn_context.activity.from_property.name
await turn_context.send_activity(
f"It is a good practice to welcome the user and provide personal greeting. For example: Welcome {name}"
)
Verarbeiten von zusätzlicher Eingabe
Nachdem ein neuer Benutzer begrüßt wurde, werden Informationen zur Benutzereingabe für jeden Nachrichten-Turn ausgewertet, und der Bot stellt je nach Kontext der Benutzereingabe eine Antwort bereit. Im folgenden Code ist die Entscheidungslogik dargestellt, die zum Generieren dieser Antwort verwendet wird.
Mit der Eingabe „intro“ oder „help“ wird die Funktion SendIntroCardAsync aufgerufen, um für den Benutzer eine Hero Card mit Informationen anzuzeigen. Dieser Code wird im nächsten Abschnitt dieses Artikels beschrieben.
Bots\WelcomeUserBot.cs
switch (text)
{
case "hello":
case "hi":
await turnContext.SendActivityAsync($"You said {text}.", cancellationToken: cancellationToken);
break;
case "intro":
case "help":
await SendIntroCardAsync(turnContext, cancellationToken);
break;
default:
await turnContext.SendActivityAsync(WelcomeMessage, cancellationToken: cancellationToken);
break;
}
}
Bei der Eingabe „intro“ oder „help“ wird CardFactory verwendet, um für den Benutzer eine einführende adaptive Karte anzuzeigen. Dieser Code wird im nächsten Abschnitt dieses Artikels beschrieben.
bots/welcomeBot.js
// This example uses an exact match on user's input utterance.
// Consider using LUIS or QnA for Natural Language Processing.
const text = context.activity.text.toLowerCase();
switch (text) {
case 'hello':
case 'hi':
await context.sendActivity(`You said "${ context.activity.text }"`);
break;
case 'intro':
case 'help':
await this.sendIntroCard(context);
break;
default:
await context.sendActivity(`This is a simple Welcome Bot sample. You can say 'intro' to
see the introduction card. If you are running this bot in the Bot
Framework Emulator, press the 'Start Over' button to simulate user joining a bot or a channel`);
}
Mit der Eingabe „intro“ oder „help“ wird die Funktion sendIntroCard aufgerufen, um für den Benutzer eine Hero Card mit Informationen anzuzeigen. Dieser Code wird im nächsten Abschnitt dieses Artikels beschrieben.
WelcomeUserBot.java
// This example hardcodes specific utterances.
// You should use LUIS or QnA for more advance language understanding.
String text = turnContext.getActivity().getText().toLowerCase();
switch (text) {
case "hello":
case "hi":
return turnContext.sendActivities(MessageFactory.text("You said " + text));
case "intro":
case "help":
return sendIntroCard(turnContext);
default:
return turnContext.sendActivity(WELCOME_MESSAGE);
}
Wenn ein Benutzer intro (Einführung) oder help (Hilfe) eingibt, ruft der Bot __send_intro_card auf. Dadurch wird für den Benutzer eine adaptive Einführungskarte angezeigt.
bots/welcome-user-bot.py
if text in ("hello", "hi"):
await turn_context.send_activity(f"You said { text }")
elif text in ("intro", "help"):
await self.__send_intro_card(turn_context)
else:
await turn_context.send_activity(self.WELCOME_MESSAGE)
Verwenden der Hero Card-Begrüßung
Wie oben bereits erwähnt, wird bei einigen Benutzereingaben als Reaktion auf die Anforderung eine Hero Card generiert. Weitere Informationen zu Hero Card-Begrüßungen finden Sie unter Hinzufügen von Medien zu Nachrichten. Unten ist der Code angegeben, der zum Erstellen der Hero Card und Antwort dieses Bots erforderlich ist.
{
var card = new HeroCard
{
Title = "Welcome to Bot Framework!",
Text = @"Welcome to Welcome Users bot sample! This Introduction card
is a great way to introduce your Bot to the user and suggest
some things to get them started. We use this opportunity to
recommend a few next steps for learning more creating and deploying bots.",
Images = new List<CardImage>() { new CardImage("https://aka.ms/bf-welcome-card-image") },
Buttons = new List<CardAction>()
{
new CardAction(ActionTypes.OpenUrl, "Get an overview", null, "Get an overview", "Get an overview", "https://docs.microsoft.com/en-us/azure/bot-service/?view=azure-bot-service-4.0"),
new CardAction(ActionTypes.OpenUrl, "Ask a question", null, "Ask a question", "Ask a question", "https://stackoverflow.com/questions/tagged/botframework"),
new CardAction(ActionTypes.OpenUrl, "Learn how to deploy", null, "Learn how to deploy", "Learn how to deploy", "https://docs.microsoft.com/en-us/azure/bot-service/bot-builder-howto-deploy-azure?view=azure-bot-service-4.0"),
}
};
var response = MessageFactory.Attachment(card.ToAttachment());
await turnContext.SendActivityAsync(response, cancellationToken);
}
}
bots/welcomeBot.js
async sendIntroCard(context) {
const card = CardFactory.heroCard(
'Welcome to Bot Framework!',
'Welcome to Welcome Users bot sample! This Introduction card is a great way to introduce your Bot to the user and suggest some things to get them started. We use this opportunity to recommend a few next steps for learning more creating and deploying bots.',
['https://aka.ms/bf-welcome-card-image'],
[
{
type: ActionTypes.OpenUrl,
title: 'Get an overview',
value: 'https://docs.microsoft.com/en-us/azure/bot-service/?view=azure-bot-service-4.0'
},
{
type: ActionTypes.OpenUrl,
title: 'Ask a question',
value: 'https://stackoverflow.com/questions/tagged/botframework'
},
{
type: ActionTypes.OpenUrl,
title: 'Learn how to deploy',
value: 'https://docs.microsoft.com/en-us/azure/bot-service/bot-builder-howto-deploy-azure?view=azure-bot-service-4.0'
}
]
);
await context.sendActivity({ attachments: [card] });
}
WelcomeUserBot.java
private CompletableFuture<ResourceResponse> sendIntroCard(TurnContext turnContext) {
HeroCard card = new HeroCard();
card.setTitle("Welcome to Bot Framework!");
card.setText(
"Welcome to Welcome Users bot sample! This Introduction card "
+ "is a great way to introduce your Bot to the user and suggest "
+ "some things to get them started. We use this opportunity to "
+ "recommend a few next steps for learning more creating and deploying bots."
);
CardImage image = new CardImage();
image.setUrl("https://aka.ms/bf-welcome-card-image");
card.setImages(Collections.singletonList(image));
CardAction overviewAction = new CardAction();
overviewAction.setType(ActionTypes.OPEN_URL);
overviewAction.setTitle("Get an overview");
overviewAction.setText("Get an overview");
overviewAction.setDisplayText("Get an overview");
overviewAction.setValue(
"https://docs.microsoft.com/en-us/azure/bot-service/?view=azure-bot-service-4.0"
);
CardAction questionAction = new CardAction();
questionAction.setType(ActionTypes.OPEN_URL);
questionAction.setTitle("Ask a question");
questionAction.setText("Ask a question");
questionAction.setDisplayText("Ask a question");
questionAction.setValue("https://stackoverflow.com/questions/tagged/botframework");
CardAction deployAction = new CardAction();
deployAction.setType(ActionTypes.OPEN_URL);
deployAction.setTitle("Learn how to deploy");
deployAction.setText("Learn how to deploy");
deployAction.setDisplayText("Learn how to deploy");
deployAction.setValue(
"https://docs.microsoft.com/en-us/azure/bot-service/bot-builder-howto-deploy-azure?view=azure-bot-service-4.0"
);
card.setButtons(Arrays.asList(overviewAction, questionAction, deployAction));
Activity response = MessageFactory.attachment(card.toAttachment());
return turnContext.sendActivity(response);
}
bots/welcome-user-bot.py
async def __send_intro_card(self, turn_context: TurnContext):
card = HeroCard(
title="Welcome to Bot Framework!",
text="Welcome to Welcome Users bot sample! This Introduction card "
"is a great way to introduce your Bot to the user and suggest "
"some things to get them started. We use this opportunity to "
"recommend a few next steps for learning more creating and deploying bots.",
images=[CardImage(url="https://aka.ms/bf-welcome-card-image")],
buttons=[
CardAction(
type=ActionTypes.open_url,
title="Get an overview",
text="Get an overview",
display_text="Get an overview",
value="https://docs.microsoft.com/en-us/azure/bot-service/?view=azure-bot-service-4.0",
),
CardAction(
type=ActionTypes.open_url,
title="Ask a question",
text="Ask a question",
display_text="Ask a question",
value="https://stackoverflow.com/questions/tagged/botframework",
),
CardAction(
type=ActionTypes.open_url,
title="Learn how to deploy",
text="Learn how to deploy",
display_text="Learn how to deploy",
value="https://docs.microsoft.com/en-us/azure/bot-service/bot-builder-howto-deploy-azure?view=azure-bot-service-4.0",
),
],
)
return await turn_context.send_activity(
MessageFactory.attachment(CardFactory.hero_card(card))
)
Testen des Bots
Laden Sie die aktuelle Version von Bot Framework Emulator herunter, und installieren Sie sie.
Führen Sie das Beispiel lokal auf Ihrem Computer aus. Wenn Sie eine Anleitung benötigen, lesen Sie die README-Datei für das C#-Beispiel oder JavaScript-Beispiel.
Öffnen des Emulators zum Testen des Bots.
Wenn Sie eine Unterhaltung mit Ihrem Bot beginnen, sendet er Ihnen eine Reihe von Willkommensnachrichten.
Wenn Sie zum ersten Mal eine „Hallo“-Nachricht senden, antwortet Ihr Bot mit einem gewissen Rat.
Wenn Sie nachfolgende „Hallo“-Nachrichten senden, antwortet Ihr Bot mit „Sie haben Hallo gesagt“.
Senden Sie eine „Hilfe“-Nachricht an den Bot. Er antwortet mit dem Versand einer Hero-Karte.
