L’objectif principal lors de la création d’un bot est d’impliquer votre utilisateur dans une conversation utile. Pour atteindre cet objectif, l’une des meilleures méthodes consiste à s’assurer qu’à partir du moment où un utilisateur se connecte pour la première fois, il comprenne les fonctionnalités et l’utilité principales de votre bot, c’est-à-dire la raison pour laquelle il a été créé. Cet article fournit des exemples de code qui vous permettent d’accueillir les utilisateurs sur votre bot.
Remarque
Les kits de développement logiciel (SDK) JavaScript, C# et Python bot Framework continueront d'être pris en charge. Toutefois, le kit de développement logiciel (SDK) Java est mis hors service avec une prise en charge finale à long terme se terminant en novembre 2023.
Seuls les correctifs de sécurité critiques et de bogues dans ce référentiel seront appliqués.
Les bots existants créés avec le kit de développement logiciel (SDK) Java continueront à fonctionner.
Une copie de l'échantillon du mot de bienvenue à l'utilisateur en C#, JS, Java ou Python. Le code de l’exemple est utilisé pour expliquer comment envoyer des messages de bienvenue.
À propos de cet exemple de code
Cet exemple de code montre comment détecter et accueillir de nouveaux utilisateurs quand ils sont initialement connectés à votre bot. Le diagramme suivant montre le flux logique pour ce bot.
Les deux principaux événements rencontrés par le bot sont :
OnMembersAddedAsync, appel émis, lorsqu'un nouvel utilisateur se connecte à votre bot.
OnMessageActivityAsync, appel émis, lorsque votre bot reçoit une nouvelle entrée utilisateur.
Chaque fois qu'un nouvel utilisateur est connecté, le bot lui fournit un WelcomeMessage, un InfoMessage et un PatternMessage.
Quand une nouvelle entrée utilisateur est reçue, WelcomeUserState est vérifié pour voir si DidBotWelcomeUser a la valeur true. Si ce n’est pas le cas, un premier message de bienvenue est retourné à l’utilisateur.
Les deux principaux événements rencontrés par le bot sont :
onMembersAdded, appel émis, lorsqu'un nouvel utilisateur se connecte à votre bot.
onMessage, appel émis, lorsque votre bot reçoit une nouvelle entrée utilisateur.
Chaque fois qu'un nouvel utilisateur est connecté, le bot lui fournit un welcomeMessage, un infoMessage et un patternMessage.
Quand une nouvelle entrée utilisateur est reçue, welcomedUserProperty est vérifié pour voir si didBotWelcomeUser a la valeur true. Si ce n’est pas le cas, un premier message de bienvenue est retourné à l’utilisateur.
Si DidBotWelcomeUser a la valeur true, l’entrée de l’utilisateur est évaluée. En fonction du contenu de l’entrée de l’utilisateur, ce bot effectuera l’une des opérations suivantes :
Renvoyer un message d’accueil reçu de l’utilisateur.
Afficher une bannière fournissant des informations supplémentaires sur les bots.
Renvoyer le message WelcomeMessage en expliquant des entrées attendues pour ce bot.
Les deux principaux événements rencontrés par le bot sont :
onMembersAdded, appel émis, lorsqu'un nouvel utilisateur se connecte à votre bot.
onMessageActivity, appel émis, lorsque votre bot reçoit une nouvelle entrée utilisateur.
Chaque fois qu'un nouvel utilisateur est connecté, le bot lui fournit un WELCOME_MESSAGE, un INFO_MESSAGE et un PATTERN_MESSAGE.
Quand une nouvelle entrée utilisateur est reçue, WelcomeUserState est vérifié pour voir si getDidBotWelcomeUser() a la valeur true. Si ce n’est pas le cas, un premier message de bienvenue est retourné à l’utilisateur.
Les deux principaux événements rencontrés par le bot sont :
on_members_added_activity, appel émis, lorsqu'un nouvel utilisateur se connecte à votre bot.
on_message_activity, appel émis, lorsque votre bot reçoit une nouvelle entrée utilisateur.
Chaque fois qu'un nouvel utilisateur est connecté, le bot lui fournit un message de bienvenue, un message d'information et un message de modèle.
Lorsqu'une nouvelle entrée utilisateur est reçue, la propriété welcome_user_state.did_welcome_user est vérifiée. Si elle n'a pas la valeur true, un message de bienvenue initial est retourné à l'utilisateur. Si elle a la valeur true, ce bot effectue l'une des actions suivantes en fonction du contenu de l'entrée de l'utilisateur :
Renvoyer un message d’accueil reçu de l’utilisateur.
Afficher une bannière fournissant des informations supplémentaires sur les bots.
L’objet d’état utilisateur est créé au démarrage et la dépendance est injectée dans le constructeur de bot.
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;
}
Au démarrage, l’état utilisateur est défini dans index.js et il est consommé par le constructeur de bot.
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');
L'objet d'état de l'utilisateur est créé au démarrage et la dépendance est injectée dans le constructeur du bot par le conteneur Spring.
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;
}
Au démarrage, l’état utilisateur est défini dans app.py et il est consommé par le constructeur de bot.
app.py
# Create the Bot
BOT = WelcomeUserBot(USER_STATE)
# Listen for incoming requests on /api/messages.
Nous créons maintenant un accesseur de propriété pour fournir un descripteur à WelcomeUserState au sein de la méthode OnMessageActivityAsync.
Ensuite, nous appelons la méthode GetAsync pour obtenir la clé incluse dans l’étendue appropriée. Nous enregistrons alors les données d’état utilisateur après chaque itération d’entrée utilisateur à l’aide de la méthode SaveChangesAsync.
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);
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);
}
Nous créons maintenant un accesseur de propriété pour fournir un descripteur à WelcomeUserState au sein de la méthode onMessageActivity.
Ensuite, nous appelons la méthode get pour obtenir la clé incluse dans l’étendue appropriée. Nous enregistrons alors les données d’état utilisateur après chaque itération d’entrée utilisateur à l’aide de la méthode saveChanges.
WelcomeUserBot.java
// Get state data from UserState.
StatePropertyAccessor<WelcomeUserState> stateAccessor =
userState.createProperty("WelcomeUserState");
CompletableFuture<WelcomeUserState> stateFuture =
stateAccessor.get(turnContext, WelcomeUserState::new);
Il utilise l’accesseur de propriété dans le gestionnaire on_message_activity et substitue le gestionnaire on_turn pour enregistrer l’état avant la fin du tour.
# 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)
Détecter et accueillir les utilisateurs nouvellement connectés
Dans WelcomeUserBot, nous recherchons une mise à jour de l’activité à l’aide de OnMembersAddedAsync() pour voir si un nouvel utilisateur a été ajouté à la conversation, puis nous lui envoyons un ensemble de trois premiers messages de bienvenue WelcomeMessage, InfoMessage et PatternMessage. Le code complet de cette interaction est affiché ci-dessous.
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);
}
}
}
Ce code JavaScript envoie les premiers messages de bienvenue quand un utilisateur est ajouté. Pour effectuer cette opération, consultez l’activité de conversation et vérifiez qu’un nouveau membre a été ajouté à la conversation.
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();
});
Dans WelcomeUserBot, nous recherchons une mise à jour de l’activité à l’aide de onMembersAdded() pour voir si un nouvel utilisateur a été ajouté à la conversation, puis nous lui envoyons un ensemble de trois premiers messages de bienvenue WELCOME_MESSAGE, INFO_MESSAGE et PATTERN_MESSAGE. Le code complet de cette interaction est affiché ci-dessous.
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'";
on_members_added_activity vérifie si un nouvel utilisateur a été ajouté, puis envoie trois messages de bienvenue initiaux : un message de bienvenue, un message d’information et un message de modèle.
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)
Accueillir un nouvel utilisateur et ignorer l’entrée initiale
Il est également important de déterminer si l'entrée de votre utilisateur contient des informations utiles, ce qui peut varier en fonction de chaque canal. Pour vérifier que votre utilisateur bénéficie d'une bonne expérience sur tous les canaux possibles, nous examinons l'indicateur d'état didBotWelcomeUser. Si la valeur est « false », nous ne traitons pas l'entrée utilisateur initiale. Au lieu de cela, nous fournissons à l’utilisateur un premier message de bienvenue. La valeur booléenne welcomedUserProperty est ensuite définie sur « true » et stockée dans UserState. Notre code traitera désormais l’entrée de cet utilisateur à partir de toutes les activités de message supplémentaires.
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
Il est également important de déterminer si l'entrée de votre utilisateur pourrait contient des informations utiles, ce qui peut varier en fonction de chaque canal. Pour vérifier si l'utilisateur bénéficie d'une bonne expérience sur tous les canaux possibles, nous examinons la propriété didBotWelcomedUser. Si elle n'existe pas, nous lui affectons la valeur « false », et nous ne traitons pas l'entrée initiale de l'utilisateur. Au lieu de cela, nous fournissons à l’utilisateur un premier message de bienvenue. La valeur booléenne didBotWelcomeUser prend ensuite la valeur « true », puis notre code traite l’entrée utilisateur à partir de toutes les activités de message supplémentaires.
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();
});
Il est important de déterminer à quel moment les données fournies par l'utilisateur peuvent contenir des informations utiles, ce qui peut varier d'un canal à l'autre. Pour vérifier que votre utilisateur bénéficie d'une bonne expérience sur tous les canaux possibles, nous examinons l'indicateur d'état getDidBotWelcomeUser. Si la valeur est « false », nous ne traitons pas l'entrée utilisateur initiale. Au lieu de cela, nous fournissons à l’utilisateur un premier message de bienvenue. La valeur booléenne setDidBotWelcomeUser est ensuite définie sur « true » et stockée dans UserState. Notre code traitera désormais l'entrée de cet utilisateur à partir de toutes les activités de message supplémentaires.
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))
Il est également important de déterminer si l'entrée de l'utilisateur contient des informations utiles, ce qui peut varier en fonction de chaque canal. Pour garantir à l’utilisateur une bonne expérience sur tous les canaux possibles, on_message_activity vérifie la propriété did_welcome_user. La première fois, il lui affecte la valeur false et ne traite pas l'entrée utilisateur. À la place, il fournit à l’utilisateur un message de bienvenue initial. Il affecte ensuite à did_welcome_user la valeur true, puis traite l’entrée utilisateur à partir de toutes les activités de message supplémentaires.
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}"
)
Traiter une entrée supplémentaire
Une fois qu'un nouvel utilisateur a été accueilli, les informations d'entrée utilisateur sont évaluées pour chaque tour de message, et le bot fournit une réponse en fonction du contexte de cette entrée utilisateur. Le code suivant illustre la logique de décision utilisée pour générer cette réponse.
Une entrée 'intro' ou 'help' appelle la fonction SendIntroCardAsync pour présenter à l’utilisateur une bannière d’informations. Ce code est examiné dans la section suivante de cet article.
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;
}
}
Une entrée 'intro' ou 'help' utilise CardFactory pour présenter à l’utilisateur une carte adaptative d’introduction. Ce code est examiné dans la section suivante de cet article.
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`);
}
Une entrée 'intro' ou 'help' appelle la fonction sendIntroCard pour présenter à l’utilisateur une bannière d’informations. Ce code est examiné dans la section suivante de cet article.
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);
}
Si un utilisateur entre intro ou help (aide), le bot appelle __send_intro_card qui présente à l'utilisateur une carte adaptative d'introduction.
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)
Utilisation d’un message de bienvenue sous forme de bannière
Comme indiqué ci-dessus, certaines entrées utilisateur génèrent une bannière en réponse à leur demande. Vous pouvez en apprendre plus sur les messages de bienvenue sous forme de bannière, consultez Envoyer une carte d’introduction. Vous trouverez ci-dessous le code nécessaire pour créer cette réponse sous forme de bannière du bot.
{
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))
)
Exécutez l’exemple en local sur votre machine. Si vous avez besoin d'instructions, reportez-vous au fichier README de l'échantillon C# ou de l'échantillon JavaScript.
Ouvrez l'émulateur pour tester votre bot
Lorsque vous démarrez une conversation avec votre bot, il vous enverra une série de messages de bienvenue.
Lorsque vous envoyez un message « hello » la première fois, votre bot répond avec quelques conseils.
Lorsque vous envoyez des messages « hello » suivants, votre bot répond avec « Vous avez dit bonjour ».
Envoyez un message « d'aide » à votre bot. Il répond en envoyant une carte de bannière.
