Üdvözlő üzenet küldése a felhasználóknak

A KÖVETKEZŐKRE VONATKOZIK: SDK v4

A robotok létrehozásakor az elsődleges cél a felhasználó bevonása egy tartalmas beszélgetésbe. Ennek a célnak az egyik legjobb módja annak biztosítása, hogy a felhasználó első kapcsolódásától kezdve tisztában legyen a robot fő céljával és képességeivel, a robot létrehozásának okával. Ez a cikk kód példákat tartalmaz, amelyek segítenek a felhasználóknak a robotban való köszöntésében.

Feljegyzés

A Bot Framework JavaScript, C# és Python SDK-k továbbra is támogatottak lesznek, a Java SDK-t azonban 2023 novemberében végső hosszú távú támogatással kivonják.

A Java SDK-val létrehozott meglévő robotok továbbra is működni fognak.

Az új robotépítéshez fontolja meg a Microsoft Copilot Studio használatát, és olvassa el a megfelelő copilot-megoldás kiválasztását.

További információ: A robotépítés jövője.

Előfeltételek

• A robot alapjainak megismerése.
• Az üdvözlőfelhasználói minta másolata c# mintában, JS-mintában, Java-mintában vagy Python-mintában. A mintakód az üdvözlő üzenetek küldésének magyarázatára szolgál.

A mintakód ismertetése

Ez a mintakód bemutatja, hogyan észlelheti és üdvözölheti az új felhasználókat, amikor először csatlakoznak a robothoz. Az alábbi ábrán a robot logikai folyamata látható.

C#

A robot két fő eseménye a következő:

• OnMembersAddedAsync, meghívja, amikor egy új felhasználó csatlakozik a robothoz.
• OnMessageActivityAsync, akkor hívja meg, amikor a robot új felhasználói bemenetet kap.

Amikor egy új felhasználó csatlakozik, egy , InfoMessageés PatternMessage a robot biztosítja WelcomeMessageőket. Amikor új felhasználói bemenet érkezik, a WelcomeUserState be van jelölve, hogy DidBotWelcomeUser igaz értékre van-e állítva. Ha nem, a rendszer egy kezdeti üdvözlő felhasználói üzenetet ad vissza a felhasználónak.

JavaScript

A robot két fő eseménye a következő:

• onMembersAdded, meghívja, amikor egy új felhasználó csatlakozik a robothoz.
• onMessage, akkor hívja meg, amikor a robot új felhasználói bemenetet kap.

Amikor egy új felhasználó csatlakozik, egy , infoMessageés patternMessage a robot biztosítja welcomeMessageőket. Ha új felhasználói bemenet érkezik, a rendszer ellenőrzi, welcomedUserProperty hogy didBotWelcomeUser igaz-e. Ha nem, a rendszer egy kezdeti üdvözlő felhasználói üzenetet ad vissza a felhasználónak. Ha DidBotWelcomeUser igaz, a rendszer kiértékeli a felhasználó bemenetét. A felhasználó bemenetének tartalma alapján a robot az alábbiak egyikét fogja elvégezni:

• Visszhangozza vissza a felhasználótól kapott üdvözletet.
• Megjeleníthet egy főképkártyát, amely további információkat biztosít a robotokról.
• Adja meg újra a WelcomeMessage robothoz várt bemenetek magyarázatát.

Java

A robot két fő eseménye a következő:

• onMembersAdded, meghívja, amikor egy új felhasználó csatlakozik a robothoz.
• onMessageActivity, akkor hívja meg, amikor a robot új felhasználói bemenetet kap.

Amikor egy új felhasználó csatlakozik, egy , INFO_MESSAGEés PATTERN_MESSAGE a robot biztosítja WELCOME_MESSAGEőket. Amikor új felhasználói bemenet érkezik, a WelcomeUserState be van jelölve, hogy getDidBotWelcomeUser() igaz értékre van-e állítva. Ha nem, a rendszer egy kezdeti üdvözlő felhasználói üzenetet ad vissza a felhasználónak.

Python

A robot két fő eseménye a következő:

• on_members_added_activity, meghívja, amikor egy új felhasználó csatlakozik a robothoz.
• on_message_activity, akkor hívja meg, amikor a robot új felhasználói bemenetet kap.

Amikor egy új felhasználó csatlakozik, a robot üdvözlőüzenetet, információs üzenetet és mintaüzenetet küld nekik. Amikor új felhasználói bemenet érkezik, a rendszer ellenőrzi a welcome_user_state.did_welcome_user tulajdonságot. Ha nem igaz értékre van állítva, a rendszer egy kezdeti üdvözlő felhasználói üzenetet ad vissza a felhasználónak. Ha igaz értékre van állítva, a felhasználó bemenetének tartalma alapján a robot az alábbiak egyikét fogja elvégezni:

• Visszhangozza vissza a felhasználótól kapott üdvözletet.
• Megjeleníthet egy főképkártyát, amely további információkat biztosít a robotokról.

Felhasználói állapot létrehozása

C#

A felhasználóállapot-objektum az indításkor jön létre, a függőség pedig a robotkonstruktorba lesz injektálva.

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.

Robotok\WelcomeUserBot.cs

// Initializes a new instance of the "WelcomeUserBot" class.
public WelcomeUserBot(UserState userState)
{
    _userState = userState;
}

JavaScript

Indításkor a felhasználói állapotot a robotkonstruktor határozza meg index.js és használja fel.

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');

Java

A felhasználói állapot objektum létrehozása indításkor történik, és a Spring-tároló a robotkonstruktorba injektálja a függőséget.

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;
}

Python

Indításkor a felhasználói állapotot a robotkonstruktor határozza meg app.py és használja fel.

app.py

# Create the Bot
BOT = WelcomeUserBot(USER_STATE)


# Listen for incoming requests on /api/messages.

Tulajdonságkiegészítők létrehozása

C#

Most létrehozunk egy tulajdonságkiegészítőt, amely egy fogópontot WelcomeUserState biztosít a OnMessageActivityAsync metóduson belül. Ezután hívja meg a GetAsync metódust a megfelelő hatókörű kulcs lekéréséhez. Ezután a metódus használatával minden egyes felhasználói bemeneti iteráció után menti a SaveChangesAsync felhasználói állapotadatokat.

Robotok\WelcomeUserState.cs

// Gets or sets whether the user has been welcomed in the conversation.
public bool DidBotWelcomeUser { get; set; } = false;

Robotok\WelcomeUserBot.cs

var didBotWelcomeUser = await welcomeUserStateAccessor.GetAsync(turnContext, () => new WelcomeUserState(), cancellationToken);

    await _userState.SaveChangesAsync(turnContext, cancellationToken: cancellationToken);
}

JavaScript

Most létrehozunk egy tulajdonság-tartozékot, amely egy leírót biztosít a welcomedUserProperty számára, amely a userState-ben megmarad.

robotok/welcomeBot.js

this.welcomedUserProperty = userState.createProperty(WELCOMED_USER);

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);
}

Java

Most létrehozunk egy tulajdonságkiegészítőt, amely egy fogópontot WelcomeUserState biztosít a onMessageActivity metóduson belül. Ezután hívja meg a get metódust a megfelelő hatókörű kulcs lekéréséhez. Ezután a metódus használatával minden egyes felhasználói bemeneti iteráció után menti a saveChanges felhasználói állapotadatokat.

WelcomeUserBot.java

// Get state data from UserState.
StatePropertyAccessor<WelcomeUserState> stateAccessor =
    userState.createProperty("WelcomeUserState");
CompletableFuture<WelcomeUserState> stateFuture =
    stateAccessor.get(turnContext, WelcomeUserState::new);

return super.onTurn(turnContext)
    .thenCompose(saveResult -> userState.saveChanges(turnContext));

Python

Ez a minta létrehoz egy beszélgetési állapottulajdonság-tartozékot user_state_accessora robotkonstruktorban.

robotok/welcome-user-bot.py

self.user_state_accessor = self._user_state.create_property("WelcomeUserState")

A kezelő tulajdonság-tartozékát on_message_activity használja, és felülbírálja a on_turn kezelőt az állapot mentéséhez a forduló vége előtt.

# 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)

Újonnan csatlakoztatott felhasználók észlelése és köszöntése

C#

A WelcomeUserBot alkalmazásban egy tevékenységfrissítést keresünk, amelyből OnMembersAddedAsync() megtudhatja, hogy új felhasználó lett-e hozzáadva a beszélgetéshez, majd három kezdeti üdvözlőüzenetet WelcomeMessageküldünk nekik, InfoMessage valamint PatternMessage. Az interakció teljes kódját alább találja.

Robotok\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);
        }
    }
}

JavaScript

Ez a JavaScript-kód kezdeti üdvözlő üzeneteket küld egy felhasználó hozzáadásakor. Ehhez ellenőrizze a beszélgetési tevékenységet, és ellenőrizze, hogy egy új tag lett-e hozzáadva a beszélgetéshez.

robotok/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();
});

Java

A WelcomeUserBot alkalmazásban egy tevékenységfrissítést keresünk, amelyből onMembersAdded() megtudhatja, hogy új felhasználó lett-e hozzáadva a beszélgetéshez, majd három kezdeti üdvözlőüzenetet WELCOME_MESSAGEküldünk nekik, INFO_MESSAGE valamint PATTERN_MESSAGE. Az interakció teljes kódját alább találja.

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'";

@Override
protected CompletableFuture<Void> onMembersAdded(
    List<ChannelAccount> membersAdded,
    TurnContext turnContext
) {
    return membersAdded.stream()
        .filter(
            member -> !StringUtils
                .equals(member.getId(), turnContext.getActivity().getRecipient().getId())
        )
        .map(
            channel -> turnContext
                .sendActivities(
                    MessageFactory.text(
                        "Hi there - " + channel.getName() + ". " + WELCOME_MESSAGE
                    ),
                    MessageFactory.text(INFO_MESSAGE),
                    MessageFactory.text(
                        localeMessage
                        + " Current locale is " + turnContext.getActivity().getLocale() + "."),
                    MessageFactory.text(PATTERN_MESSAGE)
                )
        )
        .collect(CompletableFutures.toFutureList())
        .thenApply(resourceResponses -> null);
}

Python

Ellenőrzion_members_added_activity, hogy új felhasználó lett-e hozzáadva, majd három kezdeti üdvözlőüzenetet küld: üdvözlőüzenetet, információs üzenetet és mintaüzenetet.

robotok/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)

Új felhasználó köszöntése és a kezdeti bemenet elvetése

C#

Azt is fontos figyelembe venni, hogy a felhasználó bemenete ténylegesen tartalmaz-e hasznos információkat, és ez az egyes csatornák esetében eltérő lehet. Annak érdekében, hogy a felhasználó minden lehetséges csatornán megfelelő felhasználói élményben legyen része, ellenőrizzük a didBotWelcomeUser állapotjelzőt, és ha ez "hamis", akkor nem dolgozzuk fel a kezdeti felhasználói bemenetet. Ehelyett egy kezdeti üdvözlő üzenetet küldünk a felhasználónak. A bool welcomedUserProperty ezután "true" (igaz) értékre van állítva, amelyet a UserState tárol, és a kód most feldolgozni fogja ennek a felhasználónak az összes további üzenettevékenységből származó bemenetét.

Robotok\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

    await _userState.SaveChangesAsync(turnContext, cancellationToken: cancellationToken);
}

JavaScript

Azt is fontos figyelembe venni, hogy a felhasználó bemenete ténylegesen tartalmaz-e hasznos információkat, és ez az egyes csatornák esetében eltérő lehet. Annak érdekében, hogy a felhasználó minden lehetséges csatornán megfelelő felhasználói élményben legyen része, ellenőrizzük a didBotWelcomedUser tulajdonságot, ha nem létezik, "hamis" értékre állítjuk, és nem dolgozzuk fel a kezdeti felhasználói bemenetet. Ehelyett egy kezdeti üdvözlő üzenetet küldünk a felhasználónak. A bool didBotWelcomeUser ezután "true" (igaz) értékre van állítva, és a kód feldolgozza a felhasználói bemenetet az összes további üzenettevékenységből.

robotok/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();
});

Java

Fontos megfontolni, hogy a felhasználó bemenete mikor tartalmazhat hasznos információkat, amelyek az egyes csatornák esetében eltérőek lehetnek. Annak érdekében, hogy a felhasználó minden lehetséges csatornán megfelelő felhasználói élményben legyen része, ellenőrizzük a getDidBotWelcomeUser állapotjelzőt, és ha ez "hamis", akkor nem dolgozzuk fel a kezdeti felhasználói bemenetet. Ehelyett egy kezdeti üdvözlő üzenetet küldünk a felhasználónak. A bool setDidBotWelcomeUser ezután "true" (igaz) értékre van állítva, amelyet a UserState tárol, és a kód most feldolgozni fogja ennek a felhasználónak az összes további üzenettevékenységből származó bemenetét.

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))                

Python

Azt is fontos figyelembe venni, hogy a felhasználó bemenete valóban tartalmaz-e hasznos információkat, ez az egyes csatornák esetében eltérő lehet. Annak érdekében, hogy a felhasználó minden lehetséges csatornán jó felhasználói élményben legyen része, on_message_activity ellenőrizze a tulajdonságot did_welcome_user . Az első alkalommal hamis értékre állítja, és nem dolgozza fel a felhasználói bemenetet. Ehelyett egy kezdeti üdvözlő üzenetet küld a felhasználónak. Ezután igaz értékre állítjadid_welcome_user, és feldolgozza a felhasználói bemenetet az összes további üzenettevékenységből.

robotok/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}"
    )

További bemenet feldolgozása

Miután egy új felhasználót üdvözölt, a rendszer kiértékeli a felhasználói bemeneti adatokat minden egyes üzenetfordulónál, és a robot a felhasználói bemenet kontextusa alapján választ ad. Az alábbi kód a válasz létrehozásához használt döntési logikát mutatja be.

C#

Az "intro" vagy a "súgó" bemenete meghívja a függvényt SendIntroCardAsync , hogy egy információs főkártyával mutassa be a felhasználót. Ezt a kódot a cikk következő szakaszában vizsgáljuk meg.

Robotok\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;
    }
}

JavaScript

Az "intro" vagy a "súgó" bemenete a CardFactory használatával mutatja be a felhasználót egy Bevezető adaptív kártyával. Ezt a kódot a cikk következő szakaszában vizsgáljuk meg.

robotok/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`);
}

Java

Az "intro" vagy a "súgó" bemenete meghívja a függvényt sendIntroCard , hogy egy információs főkártyával mutassa be a felhasználót. Ezt a kódot a cikk következő szakaszában vizsgáljuk meg.

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);
}

Python

A felhasználó bevezető bemenete vagy segítsége a robot hívását __send_intro_cardokozza, amely bevezető adaptív kártyával jeleníti meg a felhasználót.

robotok/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)

A fő képkártya üdvözlőlapjának használata

Ahogy fentebb említettük, egyes felhasználói bemenetek hőskártyát hoznak létre a kérésükre válaszul. A fő képkártyák üdvözléséről itt olvashat bővebben: Intro Card küldése. Az alábbiakban a robot főkártya-válaszának létrehozásához szükséges kód látható.

C#

Robotok\WelcomeUserBot.cs

    {
        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);
    }
}

JavaScript

robotok/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] });
}

Java

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);
}

Python

robotok/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))
    )

A robot tesztelése

Töltse le és telepítse a legújabb Bot Framework Emulatort

1. Futtassa a mintát helyileg a számítógépen. Ha útmutatásra van szüksége, tekintse meg a README C# vagy JavaScript-minta fájlát.
2. Nyissa meg az Emulátort a robot teszteléséhez.

   1. Amikor beszélgetést indít a robottal, az üdvözlő üzenetek sorozatát küldi el Önnek.

   2. Amikor első alkalommal küld "hello" üzenetet, a robot néhány tanácsot ad.

   3. Amikor további "hello" üzeneteket küld, a robot a következővel válaszol: "Hello".

      

   4. Küldjön egy "súgó" üzenetet a robotnak. Egy főkártya küldésével válaszol.

      

További források

További információ a különböző médiaválaszokról a Média hozzáadása üzenetekhez című témakörben.

Következő lépések

Felhasználói bevitel összegyűjtése