O objetivo principal ao criar qualquer bot é envolver seu usuário em uma conversa significativa. Uma das melhores maneiras de atingir esse objetivo é garantir que, a partir do momento em que um usuário se conecta pela primeira vez, ele entende o objetivo principal e os recursos do seu bot, a razão pela qual seu bot foi criado. Este artigo fornece exemplos de código para ajudá-lo a receber usuários em seu bot.
Nota
Os SDKs JavaScript, C# e Python do Bot Framework continuarão a ser suportados, no entanto, o Java SDK está sendo desativado com suporte final de longo prazo terminando em novembro de 2023.
Os bots existentes construídos com o Java SDK continuarão a funcionar.
Uma cópia do exemplo de usuário de boas-vindas em C# Sample, JS Sample, Java Sample ou Python Sample. O código do exemplo é usado para explicar como enviar mensagens de boas-vindas.
Sobre este código de exemplo
Este código de exemplo mostra como detetar e receber novos usuários quando eles estão inicialmente conectados ao seu bot. O diagrama a seguir mostra o fluxo lógico para esse bot.
Os dois principais eventos encontrados pelo bot são:
OnMembersAddedAsync, chamado quando um novo usuário se conecta ao seu bot.
OnMessageActivityAsync, chamado quando o bot recebe uma nova entrada do usuário.
Sempre que um novo usuário é conectado, ele recebe um WelcomeMessage, InfoMessagee PatternMessage pelo bot.
Quando uma nova entrada de usuário é recebida, WelcomeUserState é verificado para ver se DidBotWelcomeUser está definido como true. Caso contrário, uma mensagem inicial de boas-vindas do usuário será retornada ao usuário.
Os dois principais eventos encontrados pelo bot são:
onMembersAdded, chamado quando um novo usuário se conecta ao seu bot.
onMessage, chamado quando o bot recebe uma nova entrada do usuário.
Sempre que um novo usuário é conectado, ele recebe um welcomeMessage, infoMessagee patternMessage pelo bot.
Quando uma nova entrada de usuário é recebida, welcomedUserProperty é verificado se didBotWelcomeUser está definido como true. Caso contrário, uma mensagem inicial de boas-vindas do usuário será retornada ao usuário.
Se DidBotWelcomeUser for verdadeiro, a entrada do usuário é avaliada. Com base no conteúdo da entrada do usuário, esse bot fará o seguinte:
Ecoar de volta uma saudação recebida do usuário.
Exiba um cartão de herói com informações adicionais sobre bots.
Reenvie as WelcomeMessage entradas esperadas explicativas para este bot.
Os dois principais eventos encontrados pelo bot são:
onMembersAdded, chamado quando um novo usuário se conecta ao seu bot.
onMessageActivity, chamado quando o bot recebe uma nova entrada do usuário.
Sempre que um novo usuário é conectado, ele recebe um WELCOME_MESSAGE, INFO_MESSAGEe PATTERN_MESSAGE pelo bot.
Quando uma nova entrada de usuário é recebida, WelcomeUserState é verificado para ver se getDidBotWelcomeUser() está definido como true. Caso contrário, uma mensagem inicial de boas-vindas do usuário será retornada ao usuário.
Os dois principais eventos encontrados pelo bot são:
on_members_added_activity, chamado quando um novo usuário se conecta ao seu bot.
on_message_activity, chamado quando o bot recebe uma nova entrada do usuário.
Sempre que um novo usuário é conectado, ele recebe uma mensagem de boas-vindas, uma mensagem informativa e uma mensagem padrão do bot.
Quando uma nova entrada de usuário é recebida, a welcome_user_state.did_welcome_user propriedade é verificada. Se não estiver definido como true, uma mensagem inicial de boas-vindas do usuário será retornada ao usuário. Se estiver definido como true, com base no conteúdo da entrada do usuário, esse bot fará o seguinte:
Ecoar de volta uma saudação recebida do usuário.
Exiba um cartão de herói com informações adicionais sobre bots.
O objeto de estado do usuário é criado na inicialização e a dependência é injetada no construtor do 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;
}
Na inicialização, o estado do usuário é definido index.js e consumido pelo construtor do 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');
O objeto de estado do usuário é criado na inicialização e a dependência é injetada no construtor do bot pelo contêiner 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;
}
Na inicialização, o estado do usuário é definido app.py e consumido pelo construtor do bot.
app.py
# Create the Bot
BOT = WelcomeUserBot(USER_STATE)
# Listen for incoming requests on /api/messages.
Agora criamos um acessador de propriedade que nos fornece um identificador para WelcomeUserState dentro do OnMessageActivityAsync método.
Em seguida, chame o GetAsync método para obter a chave com escopo adequado. Em seguida, salvamos os dados de estado do usuário após cada iteração de entrada do usuário usando o SaveChangesAsync método.
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);
}
Agora criamos um acessador de propriedade que nos fornece um identificador para WelcomeUserState dentro do onMessageActivity método.
Em seguida, chame o get método para obter a chave com escopo adequado. Em seguida, salvamos os dados de estado do usuário após cada iteração de entrada do usuário usando o saveChanges método.
WelcomeUserBot.java
// Get state data from UserState.
StatePropertyAccessor<WelcomeUserState> stateAccessor =
userState.createProperty("WelcomeUserState");
CompletableFuture<WelcomeUserState> stateFuture =
stateAccessor.get(turnContext, WelcomeUserState::new);
Ele usa o acessador de propriedade no on_message_activity manipulador e substitui o on_turn manipulador para salvar o estado antes do final do turno.
# 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)
No WelcomeUserBot, verificamos se há uma atualização de atividade usando OnMembersAddedAsync() para ver se um novo usuário foi adicionado à conversa e, em seguida, enviamos a eles um conjunto de três mensagens WelcomeMessagede boas-vindas iniciais , InfoMessage e PatternMessage. O código completo para esta interação é mostrado abaixo.
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);
}
}
}
Esse código JavaScript envia mensagens de boas-vindas iniciais quando um usuário é adicionado. Isso é feito verificando a atividade da conversa e verificando se um novo membro foi adicionado à conversa.
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();
});
No WelcomeUserBot, verificamos se há uma atualização de atividade usando onMembersAdded() para ver se um novo usuário foi adicionado à conversa e, em seguida, enviamos a eles um conjunto de três mensagens WELCOME_MESSAGEde boas-vindas iniciais , INFO_MESSAGE e PATTERN_MESSAGE. O código completo para esta interação é mostrado abaixo.
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'";
O on_members_added_activity verifica se um novo usuário foi adicionado e, em seguida, envia três mensagens de boas-vindas iniciais: uma mensagem de boas-vindas, uma mensagem informativa e uma mensagem padrão.
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)
Dê as boas-vindas ao novo usuário e descarte a entrada inicial
Também é importante considerar quando a entrada do usuário pode realmente conter informações úteis, e isso pode variar para cada canal. Para garantir que seu usuário tenha uma boa experiência em todos os canais possíveis, verificamos a bandeira de status didBotWelcomeUser e, se isso for "falso", não processamos a entrada inicial do usuário. Em vez disso, fornecemos ao usuário uma mensagem inicial de boas-vindas. O bool welcomedUserProperty é então definido como "true", armazenado em UserState e nosso código agora processará a entrada desse usuário de todas as atividades de mensagem adicionais.
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
Também é importante considerar quando a entrada do usuário pode realmente conter informações úteis, e isso pode variar para cada canal. Para garantir que seu usuário tenha uma boa experiência em todos os canais possíveis, verificamos a propriedade didBotWelcomedUser, se ela não existir, a definimos como "false" e não processamos a entrada inicial do usuário. Em vez disso, fornecemos ao usuário uma mensagem inicial de boas-vindas. O bool didBotWelcomeUser é então definido como "true" e nosso código processa a entrada do usuário de todas as atividades de mensagem adicionais.
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();
});
É importante considerar quando a entrada do usuário pode conter informações úteis, que podem variar para cada canal. Para garantir que seu usuário tenha uma boa experiência em todos os canais possíveis, verificamos o sinalizador de status getDidBotWelcomeUser e, se isso for "falso", não processamos a entrada inicial do usuário. Em vez disso, fornecemos ao usuário uma mensagem inicial de boas-vindas. O bool setDidBotWelcomeUser é então definido como "true", armazenado em UserState e nosso código agora processará a entrada desse usuário de todas as atividades de mensagem adicionais.
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))
Também é importante considerar quando a entrada do usuário pode realmente conter informações úteis, isso pode variar para cada canal. Para garantir que o usuário tenha uma boa experiência em todos os canais possíveis, on_message_activity verifique a did_welcome_user propriedade. Na primeira vez, ele define como false e não processa a entrada do usuário. Em vez disso, ele fornece ao usuário uma mensagem inicial de boas-vindas. Em seguida, ele define did_welcome_user como true e processa a entrada do usuário de todas as atividades de mensagem adicionais.
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}"
)
Entrada adicional do processo
Depois que um novo usuário é bem-vindo, as informações de entrada do usuário são avaliadas para cada turno de mensagem, e o bot fornece uma resposta com base no contexto dessa entrada do usuário. O código a seguir mostra a lógica de decisão usada para gerar essa resposta.
Uma entrada de 'intro' ou 'ajuda' chama a função SendIntroCardAsync para apresentar ao usuário um cartão herói informativo. Esse código é examinado na próxima seção deste artigo.
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;
}
}
Uma entrada de 'intro' ou 'help' usa o CardFactory para apresentar ao usuário um Intro Adaptive Card. Esse código é examinado na próxima seção deste artigo.
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`);
}
Uma entrada de 'intro' ou 'ajuda' chama a função sendIntroCard para apresentar ao usuário um cartão herói informativo. Esse código é examinado na próxima seção deste artigo.
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);
}
A entrada de introdução ou ajuda de um usuário faz com que o bot chame __send_intro_card, o que apresenta ao usuário um cartão adaptável de introdução.
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)
Usando a saudação do cartão de herói
Como mencionado acima, algumas entradas do usuário geram um cartão de herói em resposta à sua solicitação. Você pode saber mais sobre saudações de cartão de herói aqui Envie um cartão de introdução. Abaixo está o código necessário para criar a resposta do cartão herói deste 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))
)
