Die Codebeispiele in diesem Abschnitt basieren auf Version 4.6 und höheren Versionen des Bot Framework SDK. Wenn Sie nach Dokumentation zu früheren Versionen suchen, lesen Sie den Abschnitt bots – v3 SDK im Ordner Legacy SDKs der Dokumentation.
Wenn Sie Unterhaltungs-Bots für Microsoft Teams erstellen, können Sie mit Unterhaltungsereignissen arbeiten. Microsoft Teams sendet Benachrichtigungen an Ihren Bot für Unterhaltungsereignisse, die in Bereichen stattfinden, in denen Ihr Bot aktiv ist. Sie können diese Ereignisse in Ihrem Code erfassen und die folgenden Aktionen ausführen:
Auslösen einer Willkommensnachricht, wenn Ihr Bot einem Team hinzugefügt ist.
Auslösen einer Willkommensnachricht, wenn ein neues Teammitglied hinzugefügt oder eins entfernt wird.
Auslösen einer Benachrichtigung, wenn ein Kanal erstellt, umbenannt oder gelöscht wird.
Auslösen einer Benachrichtigung, wenn eine Botnachricht von einem Benutzer mit „Gefällt mir“ markiert wird.
Identifizieren Sie den Standardkanal für Ihren Bot anhand der Benutzereingabe (Auswahl) während der Installation.
Das folgende Video zeigt, wie ein Konversationsbot die Kundenbindung durch reibungslose, intelligente Interaktionen verbessern kann:
Aktualisierungsereignisse in Unterhaltungen
Sie können Unterhaltungsaktualisierungsereignisse verwenden, um bessere Benachrichtigungen und effektive Botaktionen bereitzustellen.
Wichtig
Sie können jederzeit neue Ereignisse hinzufügen, und Ihr Bot beginnt, sie zu empfangen.
Sie müssen Ihren Bot so entwerfen, dass er unerwartete Ereignisse empfängt.
Wenn Sie das Bot Framework SDK verwenden, antwortet Ihr Bot automatisch mit einem 200 - OK auf jedes Ereignis, das Sie nicht behandeln möchten.
Wenn ein Azure Communication Services -Client (ACS) der Teams-Besprechung beitritt oder diese verlässt, werden keine Konversationsaktualisierungsereignisse ausgelöst.
Ein Bot empfängt in einem der folgenden Fälle ein conversationUpdate Ereignis:
Wenn der Bot einer Unterhaltung hinzugefügt wird.
Andere Mitglieder werden einer Unterhaltung hinzugefügt oder daraus entfernt.
Unterhaltungsmetadaten wurden geändert.
Das conversationUpdate-Ereignis wird an Ihren Bot gesendet, wenn er Informationen zu Mitgliedschaftsaktualisierungen für Teams empfängt, denen er hinzugefügt wurde. Er empfängt außerdem eine Aktualisierung, wenn er zum ersten Mal hinzugefügt wurde, speziell für persönliche Unterhaltungen.
In der folgenden Tabelle finden Sie eine Liste mit Teams-Unterhaltungsaktualisierungsereignissen mit weiteren Details:
protected override async Task OnTeamsChannelCreatedAsync(ChannelInfo channelInfo, TeamInfo teamInfo, ITurnContext<IConversationUpdateActivity> turnContext, CancellationToken cancellationToken)
{
var heroCard = new HeroCard(text: $"{channelInfo.Name} is the Channel created");
// Sends an activity to the sender of the incoming activity.
await turnContext.SendActivityAsync(MessageFactory.Attachment(heroCard.ToAttachment()), cancellationToken);
}
async def on_teams_channel_created(
self, channel_info: ChannelInfo, team_info: TeamInfo, turn_context: TurnContext
):
# Sends a message activity to the sender of the incoming activity.
return await turn_context.send_activity(
MessageFactory.text(
f"The new channel is {channel_info.name}. The channel id is {channel_info.id}"
)
)
Kanal umbenannt
Das channelRenamed Ereignis wird immer dann an Ihren Bot gesendet, wenn ein Kanal in einem Team umbenannt wird, in dem Ihr Bot installiert ist.
Der folgende Code zeigt ein Beispiel für ein Kanalereignis, das umbenannt wurde:
protected override async Task OnTeamsChannelRenamedAsync(ChannelInfo channelInfo, TeamInfo teamInfo, ITurnContext<IConversationUpdateActivity> turnContext, CancellationToken cancellationToken)
{
var heroCard = new HeroCard(text: $"{channelInfo.Name} is the new Channel name");
// Sends an activity to the sender of the incoming activity.
await turnContext.SendActivityAsync(MessageFactory.Attachment(heroCard.ToAttachment()), cancellationToken);
}
async def on_teams_channel_deleted(
self, channel_info: ChannelInfo, team_info: TeamInfo, turn_context: TurnContext
):
# Sends a message activity to the sender of the incoming activity.
return await turn_context.send_activity(
MessageFactory.text(f"The deleted channel is {channel_info.name}")
)
Kanal wiederhergestellt
Das channelRestored Ereignis wird an Ihren Bot gesendet, wenn ein zuvor gelöschter Kanal in einem Team wiederhergestellt wird, in dem Ihr Bot bereits installiert ist.
Der folgende Code zeigt ein Beispiel für ein Kanalereignis, das wiederhergestellt wurde:
async def on_teams_channel_restored(
self, channel_info: ChannelInfo, team_info: TeamInfo, turn_context: TurnContext
):
# Sends a message activity to the sender of the incoming activity.
return await turn_context.send_activity(
MessageFactory.text(
f"The restored channel is {channel_info.name}. The channel id is {channel_info.id}"
)
)
Mitglieder hinzugefügt
In den folgenden Szenarien wird ein Mitglied hinzugefügtes Ereignis an Ihren Bot gesendet:
Wenn der Bot selbst installiert und einer Unterhaltung hinzugefügt wird
Im Teamkontext wird die conversation.id der Aktivität auf den id des Kanals festgelegt, den der Benutzer während der App-Installation ausgewählt hat, oder auf den Kanal, in dem der Bot installiert wurde.
Wenn ein Benutzer zu einer Unterhaltung hinzugefügt wird, in der der Bot installiert ist
Benutzer-IDs, die in der Ereignisnutzlast empfangen werden, sind für den Bot eindeutig und können für die zukünftige Verwendung zwischengespeichert werden, z. B. für das direkte Senden eines Benutzers.
Die vom Mitglied hinzugefügte Aktivität eventType wird auf teamMemberAdded festgelegt, wenn das Ereignis aus einem Teamkontext gesendet wird. Überprüfen Sie Activity das -Objekt von turnContext, um festzustellen, ob das neu hinzugefügte Element der Bot selbst oder ein Benutzer war. Wenn die MembersAdded Liste ein -Objekt enthält, wobei id mit dem id Feld des Recipient Objekts identisch ist, ist der hinzugefügte Member der Bot, andernfalls ist es ein Benutzer. Die des Bots id ist als 28:<MicrosoftAppId>formatiert.
Tipp
Verwenden Sie das InstallationUpdate -Ereignis , um zu bestimmen, wann Ihr Bot einer Unterhaltung hinzugefügt oder daraus entfernt wird.
Der folgende Code zeigt ein Beispiel für ein Ereignis, das von Teammitgliedern hinzugefügt wurde:
protected override async Task OnTeamsMembersAddedAsync(IList<TeamsChannelAccount> teamsMembersAdded , TeamInfo teamInfo, ITurnContext<IConversationUpdateActivity> turnContext, CancellationToken cancellationToken)
{
foreach (TeamsChannelAccount member in teamsMembersAdded)
{
if (member.Id == turnContext.Activity.Recipient.Id)
{
// Send a message to introduce the bot to the team.
var heroCard = new HeroCard(text: $"The {member.Name} bot has joined {teamInfo.Name}");
// Sends an activity to the sender of the incoming activity.
await turnContext.SendActivityAsync(MessageFactory.Attachment(heroCard.ToAttachment()), cancellationToken);
}
else
{
var heroCard = new HeroCard(text: $"{member.Name} joined {teamInfo.Name}");
// Sends an activity to the sender of the incoming activity.
await turnContext.SendActivityAsync(MessageFactory.Attachment(heroCard.ToAttachment()), cancellationToken);
}
}
}
export class MyBot extends TeamsActivityHandler {
constructor() {
super();
this.onTeamsMembersAddedEvent(async (membersAdded: ChannelAccount[], teamInfo: TeamInfo, turnContext: TurnContext, next: () => Promise<void>): Promise<void> => {
let newMembers: string = '';
console.log(JSON.stringify(membersAdded));
membersAdded.forEach((account) => {
newMembers += account.id + ' ';
});
const name = !teamInfo ? 'not in team' : teamInfo.name;
const card = CardFactory.heroCard('Account Added', `${newMembers} joined ${name}.`);
const message = MessageFactory.attachment(card);
// Sends a message activity to the sender of the incoming activity.
await turnContext.sendActivity(message);
await next();
});
}
}
Die Nachricht, die Ihr Bot empfängt, wenn der Bot einem Team hinzugefügt wird.
Hinweis
In dieser Nutzlast conversation.id sind und channelData.settings.selectedChannel.id die IDs des Kanals, den der Benutzer während der App-Installation ausgewählt hat oder von dem aus die Installation ausgelöst wurde.
async def on_teams_members_added(
self, teams_members_added: [TeamsChannelAccount], turn_context: TurnContext
):
for member in teams_members_added:
.. # Sends a message activity to the sender of the incoming activity.
await turn_context.send_activity(
MessageFactory.text(f"Welcome your new team member {member.id}")
)
return
Mitglieder entfernt
In den folgenden Szenarien wird ein Ereignis zum Entfernen eines Mitglieds an Ihren Bot gesendet:
Wenn der Bot selbst deinstalliert und aus einer Unterhaltung entfernt wird.
Wenn ein Benutzer aus einer Unterhaltung entfernt wird, in der der Bot installiert ist.
Die Aktivität eventType "Mitglied entfernt" wird auf teamMemberRemoved festgelegt, wenn das Ereignis aus einem Teamkontext gesendet wird. Um festzustellen, ob das entfernte neue Mitglied der Bot selbst war oder ein Benutzer, überprüfen Sie das Activity-Objekt des turnContext. Wenn die MembersRemoved Liste ein -Objekt enthält, wobei id mit dem id Feld des Recipient Objekts identisch ist, ist der hinzugefügte Member der Bot, andernfalls ist es ein Benutzer. Die ID des Bots ist als 28:<MicrosoftAppId>formatiert.
Hinweis
Wenn ein Benutzer dauerhaft aus einem Mandanten gelöscht wird, wird das membersRemoved conversationUpdate-Ereignis ausgelöst.
Der folgende Code zeigt ein Beispiel für ein entferntes Ereignis der Teammitglieder:
protected override async Task OnTeamsMembersRemovedAsync(IList<ChannelAccount> membersRemoved, TeamInfo teamInfo, ITurnContext<IConversationUpdateActivity> turnContext, CancellationToken cancellationToken)
{
foreach (TeamsChannelAccount member in membersRemoved)
{
if (member.Id == turnContext.Activity.Recipient.Id)
{
// The bot was removed.
// You should clear any cached data you have for this team.
}
else
{
var heroCard = new HeroCard(text: $"{member.Name} was removed from {teamInfo.Name}");
// Sends an activity to the sender of the incoming activity.
await turnContext.SendActivityAsync(MessageFactory.Attachment(heroCard.ToAttachment()), cancellationToken);
}
}
}
export class MyBot extends TeamsActivityHandler {
constructor() {
super();
this.onTeamsMembersRemovedEvent(async (membersRemoved: ChannelAccount[], teamInfo: TeamInfo, turnContext: TurnContext, next: () => Promise<void>): Promise<void> => {
let removedMembers: string = '';
console.log(JSON.stringify(membersRemoved));
membersRemoved.forEach((account) => {
removedMembers += account.id + ' ';
});
const name = !teamInfo ? 'not in team' : teamInfo.name;
const card = CardFactory.heroCard('Account Removed', `${removedMembers} removed from ${teamInfo.name}.`);
const message = MessageFactory.attachment(card);
// Sends a message activity to the sender of the incoming activity.
await turnContext.sendActivity(message);
await next();
});
}
}
Das Objekt channelData im folgenden Nutzlastbeispiel basiert auf dem Hinzufügen eines Mitglieds zu einem Team anstelle eines Gruppenchats oder dem Initiieren einer neuen 1:1-Unterhaltung:
async def on_teams_members_removed(
self, teams_members_removed: [TeamsChannelAccount], turn_context: TurnContext
):
for member in teams_members_removed:
..# Sends a message activity to the sender of the incoming activity.
await turn_context.send_activity(
MessageFactory.text(f"Say goodbye to {member.id}")
)
return
Team umbenannt
Ihr Bot wird benachrichtigt, wenn das Team, in dem er sich befindet, umbenannt wurde. Er empfängt ein conversationUpdate-Ereignis mit eventType.teamRenamed im channelData-Objekt.
Der folgende Code zeigt ein Beispiel für ein Teamereignis, das umbenannt wurde:
protected override async Task OnTeamsTeamRenamedAsync(TeamInfo teamInfo, ITurnContext<IConversationUpdateActivity> turnContext, CancellationToken cancellationToken)
{
var heroCard = new HeroCard(text: $"{teamInfo.Name} is the new Team name");
// Sends an activity to the sender of the incoming activity.
await turnContext.SendActivityAsync(MessageFactory.Attachment(heroCard.ToAttachment()), cancellationToken);
}
export class MyBot extends TeamsActivityHandler {
constructor() {
super();
// Bot is notified when the team is renamed.
this.onTeamsTeamRenamedEvent(async (teamInfo: TeamInfo, turnContext: TurnContext, next: () => Promise<void>): Promise<void> => {
const card = CardFactory.heroCard('Team Renamed', `${teamInfo.name} is the new Team name`);
const message = MessageFactory.attachment(card);
// Sends an activity to the sender of the incoming activity.
await turnContext.sendActivity(message);
await next();
});
}
}
# Bot is notified when the team is renamed.
async def on_teams_team_renamed(
self, team_info: TeamInfo, turn_context: TurnContext
):
# Sends an activity to the sender of the incoming activity.
return await turn_context.send_activity(
MessageFactory.text(f"The new team name is {team_info.name}")
)
Team gelöscht
Der Bot erhält eine Benachrichtigung, wenn das Team gelöscht wird. Er empfängt ein conversationUpdate-Ereignis mit eventType.teamDeleted im channelData-Objekt.
Der folgende Code zeigt ein Beispiel für ein Teamereignis, das gelöscht wurde:
export class MyBot extends TeamsActivityHandler {
constructor() {
super();
// Invoked when a Team Deleted event activity is received from the connector. Team Deleted corresponds to the user deleting a team.
this.onTeamsTeamDeletedEvent(async (teamInfo: TeamInfo, turnContext: TurnContext, next: () => Promise<void>): Promise<void> => {
// Handle delete event.
await next();
});
}
}
# Invoked when a Team Deleted event activity is received from the connector. Team Deleted corresponds to the user deleting a team.
async def on_teams_team_deleted(
self, team_info: TeamInfo, turn_context: TurnContext
):
# Handle delete event.
)
Team wiederhergestellt
Der Bot erhält eine Benachrichtigung, wenn ein Team nach dem Löschen wiederhergestellt wird. Er empfängt ein conversationUpdate-Ereignis mit eventType.teamrestored im channelData-Objekt.
Der folgende Code zeigt ein Beispiel für ein wiederhergestelltes Teamereignis:
protected override async Task OnTeamsTeamrestoredAsync(TeamInfo teamInfo, ITurnContext<IConversationUpdateActivity> turnContext, CancellationToken cancellationToken)
{
var heroCard = new HeroCard(text: $"{teamInfo.Name} is the team name");
// Sends an activity to the sender of the incoming activity.
await turnContext.SendActivityAsync(MessageFactory.Attachment(heroCard.ToAttachment()), cancellationToken);
}
export class MyBot extends TeamsActivityHandler {
constructor() {
super();
// Invoked when a Team Restored event activity is received from the connector. Team Restored corresponds to the user restoring a team.
this.onTeamsTeamrestoredEvent(async (teamInfo: TeamInfo, turnContext: TurnContext, next: () => Promise<void>): Promise<void> => {
const card = CardFactory.heroCard('Team restored', `${teamInfo.name} is the team name`);
const message = MessageFactory.attachment(card);
// Sends an activity to the sender of the incoming activity.
await turnContext.sendActivity(message);
await next();
});
}
}
# Invoked when a Team Restored event activity is received from the connector. Team Restored corresponds to the user restoring a team.
async def on_teams_team_restored(
self, team_info: TeamInfo, turn_context: TurnContext
):
# Sends an activity to the sender of the incoming activity.
return await turn_context.send_activity(
MessageFactory.text(f"The team name is {team_info.name}")
)
Team archiviert
Der Bot erhält eine Benachrichtigung, wenn das Team installiert und archiviert wird. Er empfängt ein conversationUpdate-Ereignis mit eventType.teamarchived im channelData-Objekt.
Der folgende Code zeigt ein Beispiel für ein archiviertes Teamereignis:
protected override async Task OnTeamsTeamArchivedAsync(TeamInfo teamInfo, ITurnContext<IConversationUpdateActivity> turnContext, CancellationToken cancellationToken)
{
var heroCard = new HeroCard(text: $"{teamInfo.Name} is the team name");
// Sends an activity to the sender of the incoming activity.
await turnContext.SendActivityAsync(MessageFactory.Attachment(heroCard.ToAttachment()), cancellationToken);
}
export class MyBot extends TeamsActivityHandler {
constructor() {
super();
// Invoked when a Team Archived event activity is received from the connector. Team Archived.
this.onTeamsTeamArchivedEvent(async (teamInfo: TeamInfo, turnContext: TurnContext, next: () => Promise<void>): Promise<void> => {
const card = CardFactory.heroCard('Team archived', `${teamInfo.name} is the team name`);
const message = MessageFactory.attachment(card);
// Sends an activity to the sender of the incoming activity.
await turnContext.sendActivity(message);
await next();
});
}
}
# Invoked when a Team Archived event activity is received from the connector. Team Archived correspond to the user archiving a team.
async def on_teams_team_archived(
self, team_info: TeamInfo, turn_context: TurnContext
):
# Sends an activity to the sender of the incoming activity.
return await turn_context.send_activity(
MessageFactory.text(f"The team name is {team_info.name}")
)
Team-Archivierung rückgängig gemacht
Der Bot erhält eine Benachrichtigung, wenn das Team installiert und die Archivierung aufgehoben wird. Er empfängt ein conversationUpdate-Ereignis mit eventType.teamUnarchived im channelData-Objekt.
Der folgende Code zeigt ein Beispiel für ein nicht archiviertes Teamereignis:
protected override async Task OnTeamsTeamUnarchivedAsync(TeamInfo teamInfo, ITurnContext<IConversationUpdateActivity> turnContext, CancellationToken cancellationToken)
{
var heroCard = new HeroCard(text: $"{teamInfo.Name} is the team name");
// Sends an activity to the sender of the incoming activity.
await turnContext.SendActivityAsync(MessageFactory.Attachment(heroCard.ToAttachment()), cancellationToken);
}
export class MyBot extends TeamsActivityHandler {
constructor() {
super();
// Invoked when a Team Unarchived event activity is received from the connector. Team.
this.onTeamsTeamUnarchivedEvent(async (teamInfo: TeamInfo, turnContext: TurnContext, next: () => Promise<void>): Promise<void> => {
const card = CardFactory.heroCard('Team archived', `${teamInfo.name} is the team name`);
const message = MessageFactory.attachment(card);
// Sends an activity to the sender of the incoming activity.
await turnContext.sendActivity(message);
await next();
});
}
}
# Invoked when a Team Unarchived event activity is received from the connector. Team Unarchived correspond to the user unarchiving a team.
async def on_teams_team_unarchived(
self, team_info: TeamInfo, turn_context: TurnContext
):
# Sends an activity to the sender of the incoming activity.
return await turn_context.send_activity(
MessageFactory.text(f"The team name is {team_info.name}")
)
Nachdem Sie nun mit den Unterhaltungsaktualisierungsereignissen gearbeitet haben, können Sie die Nachrichtenreaktionsereignisse verstehen, die für verschiedene Reaktionen auf eine Nachricht auftreten.
Ereignisse bei Nachrichtenreaktionen
Das messageReaction Ereignis wird gesendet, wenn ein Benutzer Reaktionen auf eine Nachricht hinzufügt oder entfernt, die von Ihrem Bot gesendet wurde. Die replyToId enthält die ID der Nachricht und Type ist die Art der Reaktion im Textformat. Die Arten von Reaktionen umfassen wütend, Herz, breites Grinsen, gefällt mir, traurig und überrascht. Dieses Ereignis enthält nicht den Inhalt der ursprünglichen Nachricht. Wenn die Verarbeitung von Reaktionen auf Ihre Nachrichten für Ihren Bot wichtig ist, müssen Sie die Nachrichten speichern, wenn Sie sie senden. Die folgende Tabelle enthält weitere Informationen zum Ereignistyp und zu Nutzlastobjekten:
protected override async Task OnReactionsAddedAsync(IList<MessageReaction> messageReactions, ITurnContext<IMessageReactionActivity> turnContext, CancellationToken cancellationToken)
{
foreach (var reaction in messageReactions)
{
var newReaction = $"You reacted with '{reaction.Type}' to the following message: '{turnContext.Activity.ReplyToId}'";
var replyActivity = MessageFactory.Text(newReaction);
// Sends an activity to the sender of the incoming activity.
var resourceResponse = await turnContext.SendActivityAsync(replyActivity, cancellationToken);
}
}
export class MyBot extends TeamsActivityHandler {
constructor() {
super();
// Override this in a derived class to provide logic for when reactions to a previous activity.
this.onReactionsAdded(async (context, next) => {
const reactionsAdded = context.activity.reactionsAdded;
if (reactionsAdded && reactionsAdded.length > 0) {
for (let i = 0; i < reactionsAdded.length; i++) {
const reaction = reactionsAdded[i];
const newReaction = `You reacted with '${reaction.type}' to the following message: '${context.activity.replyToId}'`;
// Sends an activity to the sender of the incoming activity.
const resourceResponse = context.sendActivity(newReaction);
// Save information about the sent message and its ID (resourceResponse.id).
}
}
});
}
}
# Override this in a derived class to provide logic for when reactions to a previous activity are added to the conversation.
async def on_reactions_added(
self, message_reactions: List[MessageReaction], turn_context: TurnContext
):
for reaction in message_reactions:
activity = await self._log.find(turn_context.activity.reply_to_id)
if not activity:
# Sends an activity to the sender of the incoming activity.
await self._send_message_and_log_activity_id(
turn_context,
f"Activity {turn_context.activity.reply_to_id} not found in log",
)
else:
# Sends an activity to the sender of the incoming activity.
await self._send_message_and_log_activity_id(
turn_context,
f"You added '{reaction.type}' regarding '{activity.text}'",
)
return
Aus Bot-Nachricht entfernte Reaktionen
Der folgende Code zeigt ein Beispiel für Reaktionen, die aus der Bot-Nachricht entfernt wurden:
protected override async Task OnReactionsRemovedAsync(IList<MessageReaction> messageReactions, ITurnContext<IMessageReactionActivity> turnContext, CancellationToken cancellationToken)
{
foreach (var reaction in messageReactions)
{
var newReaction = $"You removed the reaction '{reaction.Type}' from the following message: '{turnContext.Activity.ReplyToId}'";
var replyActivity = MessageFactory.Text(newReaction);
// Sends an activity to the sender of the incoming activity.
var resourceResponse = await turnContext.SendActivityAsync(replyActivity, cancellationToken);
}
}
export class MyBot extends TeamsActivityHandler {
constructor() {
super();
// Override this in a derived class to provide logic for when reactions to a previous activity.
this.onReactionsRemoved(async(context,next)=>{
const reactionsRemoved = context.activity.reactionsRemoved;
if (reactionsRemoved && reactionsRemoved.length > 0) {
for (let i = 0; i < reactionsRemoved.length; i++) {
const reaction = reactionsRemoved[i];
const newReaction = `You removed the reaction '${reaction.type}' from the message: '${context.activity.replyToId}'`;
// Sends an activity to the sender of the incoming activity.
const resourceResponse = context.sendActivity(newReaction);
// Save information about the sent message and its ID (resourceResponse.id).
}
}
});
}
}
# Override this in a derived class to provide logic specific to removed activities.
async def on_reactions_removed(
self, message_reactions: List[MessageReaction], turn_context: TurnContext
):
for reaction in message_reactions:
activity = await self._log.find(turn_context.activity.reply_to_id)
if not activity:
# Sends an activity to the sender of the incoming activity.
await self._send_message_and_log_activity_id(
turn_context,
f"Activity {turn_context.activity.reply_to_id} not found in log",
)
else:
# Sends an activity to the sender of the incoming activity.
await self._send_message_and_log_activity_id(
turn_context,
f"You removed '{reaction.type}' regarding '{activity.text}'",
)
return
Installationsupdateereignis
Der Bot empfängt ein installationUpdate-Ereignis, wenn Sie einen Bot in einem Unterhaltungsthread installieren. Die Deinstallation des Bots aus dem Thread löst auch das Ereignis aus. Bei der Installation eines Bots wird im Ereignis das Feld action auf add festgelegt, und wenn der Bot deinstalliert wird, wird das Feld action auf remove festgelegt.
Hinweis
Wenn Sie ein Upgrade für eine Anwendung durchführen, empfängt der Bot das installationUpdate -Ereignis nur zum Hinzufügen oder Entfernen eines Bots aus dem Manifest. In allen anderen Fällen wird das installationUpdate Ereignis nicht ausgelöst. Das Feld Aktion ist auf add-upgrade festgelegt, wenn Sie einen Bot hinzufügen oder auf remove-upgrade, wenn Sie einen Bot entfernen.
Updateereignis installieren
Verwenden Sie das installationUpdate-Ereignis, um eine einführende Nachricht von Ihrem Bot bei der Installation zu senden. Dieses Ereignis hilft Ihnen, Ihre Datenschutz- und Datenaufbewahrungsanforderungen zu erfüllen. Sie können auch Benutzer- oder Threaddaten bereinigen und löschen, wenn der Bot deinstalliert wird.
Ähnlich wie beim conversationUpdate Ereignis, das gesendet wird, wenn ein Bot zu einem Team hinzugefügt wird, wird die conversation.id des installationUpdate Ereignisses auf die ID des Kanals festgelegt, der von einem Benutzer während der App-Installation ausgewählt wurde, oder auf den Kanal, in dem die Installation stattgefunden hat. Die ID stellt den Kanal dar, in dem der Benutzer den Bot betreiben möchte, und muss vom Bot beim Senden einer Willkommensnachricht verwendet werden. Für Szenarien, in denen die ID des Kanals "Allgemein" explizit erforderlich ist, können Sie sie in team.idchannelDataabrufen.
In diesem Beispiel wird die conversation.id der conversationUpdate Aktivitäten und installationUpdate auf die ID des Antwortkanals im Daves Demo-Team festgelegt.
Hinweis
Die ausgewählte Kanal-ID wird nur bei installationUpdateAdd-Ereignissen festgelegt, die gesendet werden, wenn eine App in einem Team installiert wird.
async onInstallationUpdateActivity(context: TurnContext) {
var activity = context.activity.action;
if(activity == "Add") {
// Sends an activity to the sender of the incoming activity to add.
await context.sendActivity(MessageFactory.text("Added"));
}
else {
// Sends an activity to the sender of the incoming activity to uninstalled.
await context.sendActivity(MessageFactory.text("Uninstalled"));
}
}
# Override this in a derived class to provide logic specific to InstallationUpdate activities.
async def on_installation_update(self, turn_context: TurnContext):
if turn_context.activity.action == "add":
# Sends an activity to the sender of the incoming activity to add.
await turn_context.send_activity(MessageFactory.text("Added"))
else:
# Sends an activity to the sender of the incoming activity to uninstalled.
await turn_context.send_activity(MessageFactory.text("Uninstalled"))
Deinstallationsverhalten für eine persönliche App mit Bot
Wenn Sie eine App deinstallieren, wird der Bot ebenfalls deinstalliert. Wenn ein Benutzer eine Nachricht an Ihre App sendet, erhält er einen 403-Antwortcode. Ihr Bot erhält einen 403-Antwortcode für neue Nachrichten, die von Ihrem Bot gepostet wurden. Das Verhalten von Bots nach der Deinstallation im persönlichen Bereich und in den Bereichen Teams und groupChat ist jetzt angepasst. Sie können keine Nachrichten mehr senden oder empfangen, nachdem eine App deinstalliert wurde.
Ereignisbehandlung für Installations- und Deinstallationsereignisse
Wenn Sie diese Installations- und Deinstallationsereignisse verwenden, gibt es einige Fälle, in denen Bots Ausnahmen beim Empfangen unerwarteter Ereignisse von Teams gewähren, was in den folgenden Fällen auftritt:
Sie erstellen Ihren Bot ohne das Microsoft Bot Framework SDK, und daher gibt der Bot beim Empfangen eines unerwarteten Ereignisses eine Ausnahme.
Sie erstellen Ihren Bot mit dem Microsoft Bot Framework SDK, und Sie können das Standardereignisverhalten ändern, indem Sie den Basisereignishandle überschreiben.
Es ist wichtig zu wissen, dass neue Ereignisse jederzeit in der Zukunft hinzugefügt werden können und Ihr Bot sie empfängt. Sie müssen also mögliche unerwarteter Ereignisse abfangen. Wenn Sie das Bot Framework SDK verwenden, antwortet Ihr Bot automatisch mit 200 – OK auf ereignisse, die Sie nicht behandeln möchten.
Behandeln von Fehlern in Unterhaltungsereignissen
Wenn bei einem Bot bei der Behandlung verschiedener Ereignisse oder Aktivitäten ein Fehler auftritt, senden Sie keine Nachrichten, die keinen aussagekräftigen Kontext für die Konversation haben, wie im folgenden Screenshot gezeigt:
In der Entwicklungsphase ist es immer hilfreich, aussagekräftige Nachrichten in Unterhaltungen zu senden, die zusätzliche Details zu einem bestimmten Fehler für ein besseres Debuggen bereitstellen. In der Produktionsumgebung müssen Sie die Fehler oder Ereignisse jedoch in Azure-Anwendung Insights protokollieren. Weitere Informationen finden Sie unter Hinzufügen von Telemetriedaten zu Ihrem Bot.
Codebeispiel
Beispielname
Beschreibung
.NET
Node.js
Python
Manifest
Unterhaltungs-Bot
In diesem Beispiel wird gezeigt, wie Sie verschiedene Botunterhaltungsereignisse verwenden, die in Bot Framework v4 für den persönlichen Bereich und den Teams-Bereich verfügbar sind.
Die Quelle für diesen Inhalt finden Sie auf GitHub, wo Sie auch Issues und Pull Requests erstellen und überprüfen können. Weitere Informationen finden Sie in unserem Leitfaden für Mitwirkende.
