BotFrameworkAdapter class

Referenz

Paket:: botbuilder

Warnung

Diese API ist nun veraltet.

Use CloudAdapter instead.

Extends: BotAdapter

Konstruktoren

BotFrameworkAdapter(Partial<BotFrameworkAdapterSettings>)

Erstellt eine neue Instanz der BotFrameworkAdapter-Klasse .

Eigenschaften

isStreamingConnectionOpen	Wird in Streamingkontexten verwendet, um zu überprüfen, ob die Streamingverbindung für den Bot zum Senden von Aktivitäten noch geöffnet ist.
TokenApiClientCredentialsKey

Geerbte Eigenschaften

BotIdentityKey
ConnectorClientKey
OAuthScopeKey
onTurnError

Methoden

continueConversation(Partial<ConversationReference>, (context: TurnContext) => Promise<void>)	Setzt eine Unterhaltung mit einem Benutzer asynchron fort, möglicherweise nach einiger Zeit.
continueConversation(Partial<ConversationReference>, string, (context: TurnContext) => Promise<void>)	Setzt eine Unterhaltung mit einem Benutzer asynchron fort, möglicherweise nach einiger Zeit.
createConnectorClient(string)	Erstellt einen Connectorclient.
createConnectorClientWithIdentity(string, ClaimsIdentity)	Erstellen Sie einen ConnectorClient mit einem ClaimsIdentity-Objekt.
createConnectorClientWithIdentity(string, ClaimsIdentity, string)	Erstellen Sie einen ConnectorClient mit einer ClaimsIdentity-Instanz und einer expliziten Zielgruppe.
createConversation(Partial<ConversationReference>, (context: TurnContext) => Promise<void>)	Erstellt und startet asynchron eine Unterhaltung mit einem Benutzer in einem Kanal.
createConversation(Partial<ConversationReference>, Partial<ConversationParameters>, (context: TurnContext) => Promise<void>)	Erstellt und startet asynchron eine Unterhaltung mit einem Benutzer in einem Kanal.
deleteActivity(TurnContext, Partial<ConversationReference>)	Löscht eine vorhandene Aktivität asynchron. Diese Schnittstelle unterstützt das Framework und soll nicht direkt für Ihren Code aufgerufen werden. Verwenden Sie TurnContext.deleteActivity , um eine Aktivität aus Ihrem Botcode zu löschen.
deleteConversationMember(TurnContext, string)	Entfernt asynchron ein Mitglied aus der aktuellen Unterhaltung.
emulateOAuthCards(TurnContext \| string, boolean)	Sendet asynchron eine emulierte OAuth-Karte für einen Kanal. Diese Methode unterstützt das Framework und soll nicht direkt für Ihren Code aufgerufen werden.
exchangeToken(TurnContext, string, string, TokenExchangeRequest, CoreAppCredentials)	Führt asynchron einen Tokenaustauschvorgang aus, z. B. für einmaliges Anmelden.
getAadTokens(TurnContext, string, string[])	Melden Sie den Benutzer asynchron vom Tokenserver ab.
getAadTokens(TurnContext, string, string[], CoreAppCredentials)
getActivityMembers(TurnContext, string)	Listet asynchron die Member einer bestimmten Aktivität auf.
getConversationMembers(TurnContext)	Listet die Mitglieder der aktuellen Unterhaltung asynchron auf.
getConversations(TurnContext \| string, string)	Ruft für den angegebenen Kanal asynchron eine Seite der Unterhaltungen ab, an denen dieser Bot teilgenommen hat.
getSignInLink(TurnContext, string, AppCredentials, string, string)	Ruft asynchron einen Anmeldelink vom Tokenserver ab, der als Teil einer SigninCard gesendet werden kann.
getSignInLink(TurnContext, string, CoreAppCredentials, string, string)
getSignInResource(TurnContext, string, string, string, CoreAppCredentials)	Rufen Sie asynchron die unformatierte Anmelderessource ab, die für die Anmeldung an den Benutzer gesendet werden soll.
getTokenStatus(TurnContext, string, string)	Ruft asynchron den Tokenstatus für jede konfigurierte Verbindung für den angegebenen Benutzer ab.
getTokenStatus(TurnContext, string, string, CoreAppCredentials)
getUserToken(TurnContext, string, string)	Versucht asynchron, das Token für einen Benutzer abzurufen, der sich in einem Anmeldeflow befindet.
getUserToken(TurnContext, string, string, CoreAppCredentials)
process(Request, INodeSocket, INodeBuffer, (context: TurnContext) => Promise<void>)	Behandeln Sie eine Websocketverbindung, indem Sie eine Logikfunktion auf jede Streaminganforderung anwenden.
process(Request, Response, (context: TurnContext) => Promise<void>)	Verarbeiten Sie eine Webanforderung, indem Sie eine Logikfunktion anwenden.
processActivity(WebRequest, WebResponse, (context: TurnContext) => Promise<any>)	Erstellt asynchron einen Turnkontext und führt die Middlewarepipeline für eine eingehende Aktivität aus.
processActivityDirect(Activity, (context: TurnContext) => Promise<any>)	Erstellt asynchron einen Turnkontext und führt die Middlewarepipeline für eine eingehende Aktivität aus.
processRequest(IReceiveRequest)	Überprüft die Gültigkeit der Anforderung und versucht, ihr den richtigen virtuellen Endpunkt zuzuordnen. Anschließend wird eine Antwort generiert und bei Bedarf zurückgegeben.
sendActivities(TurnContext, Partial<Activity>[])	Sendet asynchron eine Reihe ausgehender Aktivitäten an einen Kanalserver. Diese Methode unterstützt das Framework und soll nicht direkt für Ihren Code aufgerufen werden. Verwenden Sie die sendActivity - oder sendActivities-Methode des Turnkontexts aus Ihrem Botcode.
signOutUser(TurnContext, string, string)	Melden Sie den Benutzer asynchron vom Tokenserver ab.
signOutUser(TurnContext, string, string, CoreAppCredentials)
updateActivity(TurnContext, Partial<Activity>)	Ersetzt asynchron eine vorherige Aktivität durch eine aktualisierte Version. Diese Schnittstelle unterstützt das Framework und soll nicht direkt für Ihren Code aufgerufen werden. Verwenden Sie TurnContext.updateActivity , um eine Aktivität aus Ihrem Botcode zu aktualisieren.
useNamedPipe((context: TurnContext) => Promise<any>, string, number, () => void)	Verbindet den Handler mit einem Named Pipe-Server und beginnt mit dem Lauschen auf eingehende Anforderungen.
useWebSocket(WebRequest, INodeSocket, INodeBuffer, (context: TurnContext) => Promise<any>)	Verarbeiten Sie die anfängliche Anforderung, um eine langlebige Verbindung über einen Streamingserver herzustellen.

Geerbte Methoden

continueConversationAsync(ClaimsIdentity, Partial<ConversationReference>, (context: TurnContext) => Promise<void>)	Setzt eine Unterhaltung mit einem Benutzer asynchron fort, möglicherweise nach einiger Zeit.
continueConversationAsync(ClaimsIdentity, Partial<ConversationReference>, string, (context: TurnContext) => Promise<void>)	Setzt eine Unterhaltung mit einem Benutzer asynchron fort, möglicherweise nach einiger Zeit.
continueConversationAsync(string, Partial<ConversationReference>, (context: TurnContext) => Promise<void>)	Setzt eine Unterhaltung mit einem Benutzer asynchron fort, möglicherweise nach einiger Zeit.
createConversationAsync(string, string, string, string, ConversationParameters, (context: TurnContext) => Promise<void>)	Erstellt eine Unterhaltung im angegebenen Kanal.
use((context: TurnContext, next: () => Promise<void>) => Promise<void> \| Middleware[])	Fügt der Pipeline des Adapters Middleware hinzu.

Details zum Konstruktor

BotFrameworkAdapter(Partial<BotFrameworkAdapterSettings>)

Erstellt eine neue Instanz der BotFrameworkAdapter-Klasse .

new BotFrameworkAdapter(settings?: Partial<BotFrameworkAdapterSettings>)

Parameter

settings: Partial<BotFrameworkAdapterSettings>

Optional. Die Einstellungen, die für diese Adapterinstanz verwendet werden sollen.

Hinweise

Wenn der settings Parameter keine Werte für channelService oder openIdMetadata enthält, überprüft der Konstruktor die Umgebungsvariablen des Prozesses auf diese Werte. Diese Werte können festgelegt werden, wenn ein Bot in Azure bereitgestellt wird und wenn dies erforderlich ist, damit der Bot ordnungsgemäß in der globalen Cloud oder in einer nationalen Cloud funktioniert.

Die BotFrameworkAdapterSettings-Klasse definiert die verfügbaren Adaptereinstellungen.

Details zur Eigenschaft

isStreamingConnectionOpen

Wird in Streamingkontexten verwendet, um zu überprüfen, ob die Streamingverbindung für den Bot zum Senden von Aktivitäten noch geöffnet ist.

boolean isStreamingConnectionOpen

Eigenschaftswert

boolean

True, wenn die Streamingverbindung geöffnet ist, andernfalls false.

TokenApiClientCredentialsKey

TokenApiClientCredentialsKey: symbol

Eigenschaftswert

symbol

Geerbte Eigenschaftsdetails

BotIdentityKey

BotIdentityKey: symbol

Eigenschaftswert

symbol

Geerbt von BotAdapter.BotIdentityKey

ConnectorClientKey

ConnectorClientKey: symbol

Eigenschaftswert

symbol

Geerbt von BotAdapter.ConnectorClientKey

OAuthScopeKey

OAuthScopeKey: symbol

Eigenschaftswert

symbol

Geerbt von BotAdapter.OAuthScopeKey

onTurnError

onTurnError: (context: TurnContext, error: Error) => Promise<void>

Eigenschaftswert

(context: TurnContext, error: Error) => Promise<void>

Geerbt von BotAdapter.onTurnError

Details zur Methode

continueConversation(Partial<ConversationReference>, (context: TurnContext) => Promise<void>)

Setzt eine Unterhaltung mit einem Benutzer asynchron fort, möglicherweise nach einiger Zeit.

function continueConversation(reference: Partial<ConversationReference>, logic: (context: TurnContext) => Promise<void>): Promise<void>

Parameter

reference: Partial<ConversationReference>

Ein Verweis auf die unterhaltung, die fortgesetzt werden soll.

logic: (context: TurnContext) => Promise<void>

Die asynchrone Methode, die aufgerufen werden soll, nachdem die Adaptermiddleware ausgeführt wurde.

Gibt zurück

Promise<void>

Hinweise

Dies wird häufig als proaktive Benachrichtigung bezeichnet. Der Bot kann proaktiv eine Nachricht an eine Unterhaltung oder einen Benutzer senden, ohne auf eine eingehende Nachricht zu warten. Beispielsweise kann ein Bot diese Methode verwenden, um Benachrichtigungen oder Coupons an einen Benutzer zu senden.

So senden Sie eine proaktive Nachricht:

Speichern Sie eine Kopie einer ConversationReference aus einer eingehenden Aktivität. Beispielsweise können Sie den Unterhaltungsverweis in einer Datenbank speichern.
Rufen Sie diese Methode auf, um die Unterhaltung zu einem späteren Zeitpunkt fortzusetzen. Verwenden Sie den gespeicherten Verweis, um auf die Unterhaltung zuzugreifen.
Bei erfolgreicher Ausführung generiert der Adapter ein TurnContext-Objekt und ruft den logic Funktionshandler auf. Verwenden Sie die logic -Funktion, um die proaktive Nachricht zu senden.

Um den Verweis aus einer beliebigen eingehenden Aktivität in der Unterhaltung zu kopieren, verwenden Sie die TurnContext.getConversationReference-Methode .

Diese Methode ähnelt der processActivity-Methode . Der Adapter erstellt einen TurnContext und leitet ihn über seine Middleware weiter, bevor er den logic Handler aufruft. Die erstellte Aktivität weist den Typ "event" und den Namen "continueConversation" auf.

Beispiel:

server.post('/api/notifyUser', async (req, res) => {
   // Lookup previously saved conversation reference.
   const reference = await findReference(req.body.refId);

   // Proactively notify the user.
   if (reference) {
      await adapter.continueConversation(reference, async (context) => {
         await context.sendActivity(req.body.message);
      });
      res.send(200);
   } else {
      res.send(404);
   }
});

continueConversation(Partial<ConversationReference>, string, (context: TurnContext) => Promise<void>)

Setzt eine Unterhaltung mit einem Benutzer asynchron fort, möglicherweise nach einiger Zeit.

function continueConversation(reference: Partial<ConversationReference>, oAuthScope: string, logic: (context: TurnContext) => Promise<void>): Promise<void>

Parameter

reference: Partial<ConversationReference>

(xref:botframework-schema. ConversationReference) der fortzusetzenden Unterhaltung.

oAuthScope: string

Der beabsichtigte Empfänger aller gesendeten Aktivitäten oder die Funktion, die aufgerufen werden soll, um die Unterhaltung fortzusetzen.

logic: (context: TurnContext) => Promise<void>

Optional. Die asynchrone Methode, die aufgerufen werden soll, nachdem die Adaptermiddleware ausgeführt wurde.

Gibt zurück

Promise<void>

createConnectorClient(string)

Erstellt einen Connectorclient.

function createConnectorClient(serviceUrl: string): ConnectorClient

Parameter

serviceUrl: string

Die Dienst-URL des Clients.

Gibt zurück

ConnectorClient

Die ConnectorClient-Instanz .

Hinweise

Überschreiben Sie dies in einer abgeleiteten Klasse, um einen Modellconnectorclient für Komponententests zu erstellen.

createConnectorClientWithIdentity(string, ClaimsIdentity)

Erstellen Sie einen ConnectorClient mit einem ClaimsIdentity-Objekt.

function createConnectorClientWithIdentity(serviceUrl: string, identity: ClaimsIdentity): Promise<ConnectorClient>

Parameter

serviceUrl: string

Die Dienst-URL des Clients.

identity: ClaimsIdentity

Claimsidentity

Gibt zurück

Promise<ConnectorClient>

Hinweise

Wenn ClaimsIdentity die Ansprüche für eine Skills-Anforderung enthält, erstellen Sie einen ConnectorClient für die Verwendung mit Skills. Leitet die richtige Zielgruppe von claimsIdentity oder der Credentials-Eigenschaft der Instanz ab.

createConnectorClientWithIdentity(string, ClaimsIdentity, string)

Erstellen Sie einen ConnectorClient mit einer ClaimsIdentity-Instanz und einer expliziten Zielgruppe.

function createConnectorClientWithIdentity(serviceUrl: string, identity: ClaimsIdentity, audience: string): Promise<ConnectorClient>

Parameter

serviceUrl: string

Die Dienst-URL des Clients.

identity: ClaimsIdentity

Claimsidentity

audience: string

Der Empfänger der ConnectorClient-Nachrichten. Normalerweise der Bot Framework-Kanaldienst oder die AppId eines anderen Bots.

Gibt zurück

Promise<ConnectorClient>

Hinweise

Wenn die gekürzte Zielgruppe keine Zeichenfolge der Länge ungleich 0 ist, wird die Zielgruppe von der ClaimsIdentity- oder anmeldeinformationseigenschaft der Instanz abgeleitet.

createConversation(Partial<ConversationReference>, (context: TurnContext) => Promise<void>)

Erstellt und startet asynchron eine Unterhaltung mit einem Benutzer in einem Kanal.

function createConversation(reference: Partial<ConversationReference>, logic: (context: TurnContext) => Promise<void>): Promise<void>

Parameter

reference: Partial<ConversationReference>

Ein Verweis für die zu erstellende Unterhaltung.

logic: (context: TurnContext) => Promise<void>

Die asynchrone Methode, die aufgerufen werden soll, nachdem die Adaptermiddleware ausgeführt wurde.

Gibt zurück

Promise<void>

Eine Zusage, die den asynchronen Vorgang darstellt

createConversation(Partial<ConversationReference>, Partial<ConversationParameters>, (context: TurnContext) => Promise<void>)

Erstellt und startet asynchron eine Unterhaltung mit einem Benutzer in einem Kanal.

function createConversation(reference: Partial<ConversationReference>, parameters: Partial<ConversationParameters>, logic: (context: TurnContext) => Promise<void>): Promise<void>

Parameter

reference: Partial<ConversationReference>

Ein Verweis für die zu erstellende Unterhaltung.

parameters: Partial<ConversationParameters>

Parameter, die beim Erstellen der Unterhaltung verwendet werden

logic: (context: TurnContext) => Promise<void>

Die asynchrone Methode, die aufgerufen werden soll, nachdem die Adaptermiddleware ausgeführt wurde.

Gibt zurück

Promise<void>

Eine Zusage, die den asynchronen Vorgang darstellt

deleteActivity(TurnContext, Partial<ConversationReference>)

Löscht eine vorhandene Aktivität asynchron. Diese Schnittstelle unterstützt das Framework und soll nicht direkt für Ihren Code aufgerufen werden. Verwenden Sie TurnContext.deleteActivity , um eine Aktivität aus Ihrem Botcode zu löschen.

function deleteActivity(context: TurnContext, reference: Partial<ConversationReference>): Promise<void>

Parameter

context: TurnContext

Das Kontextobjekt für den Turn.

reference: Partial<ConversationReference>

Unterhaltungsreferenzinformationen für die zu löschende Aktivität.

Gibt zurück

Promise<void>

Hinweise

Nicht alle Kanäle unterstützen diesen Vorgang. Für Kanäle, die dies nicht der Fall ist, löst dieser Aufruf möglicherweise eine Ausnahme aus.

deleteConversationMember(TurnContext, string)

Entfernt asynchron ein Mitglied aus der aktuellen Unterhaltung.

function deleteConversationMember(context: TurnContext, memberId: string): Promise<void>

Parameter

context: TurnContext

Das Kontextobjekt für den Turn.

memberId: string

Die ID des Mitglieds, das aus der Unterhaltung entfernt werden soll.

Gibt zurück

Promise<void>

Hinweise

Entfernen Sie die Identitätsinformationen eines Mitglieds aus der Unterhaltung.

Nicht alle Kanäle unterstützen diesen Vorgang. Für Kanäle, die dies nicht der Fall ist, löst dieser Aufruf möglicherweise eine Ausnahme aus.

emulateOAuthCards(TurnContext | string, boolean)

Sendet asynchron eine emulierte OAuth-Karte für einen Kanal. Diese Methode unterstützt das Framework und soll nicht direkt für Ihren Code aufgerufen werden.

function emulateOAuthCards(contextOrServiceUrl: TurnContext | string, emulate: boolean): Promise<void>

Parameter

contextOrServiceUrl: TurnContext | string

Die URL des Emulators.

emulate: boolean

true , um eine emulierte OAuth-Karte an den Emulator zu senden; oder false , um die Karte nicht zu senden.

Gibt zurück

Promise<void>

Hinweise

Beim Testen eines Bots im Bot Framework Emulator kann diese Methode die OAuth-Karteninteraktion emulieren.

exchangeToken(TurnContext, string, string, TokenExchangeRequest, CoreAppCredentials)

Führt asynchron einen Tokenaustauschvorgang aus, z. B. für einmaliges Anmelden.

function exchangeToken(context: TurnContext, connectionName: string, userId: string, tokenExchangeRequest: TokenExchangeRequest, appCredentials?: CoreAppCredentials): Promise<TokenResponse>

Parameter

context: TurnContext

Kontext für den aktuellen Gesprächsverlauf mit dem Benutzer.

connectionName: string

Name der zu verwendenden Authentifizierungsverbindung.

userId: string

Die Benutzer-ID, die dem Token zugeordnet wird.

tokenExchangeRequest: TokenExchangeRequest

Die Exchange-Anforderungsdetails, entweder ein zu tauschende Token oder ein URI für den Austausch.

appCredentials: CoreAppCredentials

Optional. CoreAppCredentials für OAuth.

Gibt zurück

Promise<TokenResponse>

getAadTokens(TurnContext, string, string[])

Melden Sie den Benutzer asynchron vom Tokenserver ab.

function getAadTokens(context: TurnContext, connectionName: string, resourceUrls: string[]): Promise<[key: string]: TokenResponse>

Parameter

context: TurnContext

Das Kontextobjekt für den Turn.

connectionName: string

Der Name der zu verwendenden Authentifizierungsverbindung.

resourceUrls: string[]

Die Liste der Ressourcen-URLs, für die Token abgerufen werden sollen.

Gibt zurück

Promise<[key: string]: TokenResponse>

Eine Zuordnung der TokenResponse-Objekte nach Ressourcen-URL.

getAadTokens(TurnContext, string, string[], CoreAppCredentials)

function getAadTokens(context: TurnContext, connectionName: string, resourceUrls: string[], oAuthAppCredentials?: CoreAppCredentials): Promise<[key: string]: TokenResponse>

Parameter

context: TurnContext

connectionName: string

resourceUrls: string[]

oAuthAppCredentials: CoreAppCredentials

Gibt zurück

Promise<[key: string]: TokenResponse>

getActivityMembers(TurnContext, string)

Listet asynchron die Member einer bestimmten Aktivität auf.

function getActivityMembers(context: TurnContext, activityId?: string): Promise<ChannelAccount[]>

Parameter

context: TurnContext

Das Kontextobjekt für den Turn.

activityId: string

Optional. Die ID der Aktivität, von der die Mitglieder abgerufen werden sollen. Falls nicht angegeben, wird die aktuelle Aktivitäts-ID verwendet.

Gibt zurück

Promise<ChannelAccount[]>

Ein Array von ChannelAccount-Objekten für die Benutzer, die an einer bestimmten Aktivität beteiligt sind.

Hinweise

Gibt ein Array von ChannelAccount-Objekten für die Benutzer zurück, die an einer bestimmten Aktivität beteiligt sind.

Dies unterscheidet sich von getConversationMembers darin, dass nur die Benutzer zurückgegeben werden, die direkt an der Aktivität beteiligt sind, nicht alle Mitglieder der Unterhaltung.

getConversationMembers(TurnContext)

Listet die Mitglieder der aktuellen Unterhaltung asynchron auf.

function getConversationMembers(context: TurnContext): Promise<ChannelAccount[]>

Parameter

context: TurnContext

Das Kontextobjekt für den Turn.

Gibt zurück

Promise<ChannelAccount[]>

Ein Array von ChannelAccount-Objekten für alle Benutzer, die derzeit an einer Unterhaltung beteiligt sind.

Hinweise

Gibt ein Array von ChannelAccount-Objekten für alle Benutzer zurück, die derzeit an einer Unterhaltung beteiligt sind.

Dies unterscheidet sich von getActivityMembers darin, dass alle Mitglieder der Konversation zurückgegeben werden, nicht nur diejenigen, die direkt an einer bestimmten Aktivität beteiligt sind.

getConversations(TurnContext | string, string)

Ruft für den angegebenen Kanal asynchron eine Seite der Unterhaltungen ab, an denen dieser Bot teilgenommen hat.

function getConversations(contextOrServiceUrl: TurnContext | string, continuationToken?: string): Promise<ConversationsResult>

Parameter

contextOrServiceUrl: TurnContext | string

Die URL des Kanalservers für die Abfrage oder ein TurnContext-Objekt aus einer Unterhaltung im Kanal.

continuationToken: string

Optional. Das Fortsetzungstoken der vorherigen Ergebnisseite. Lassen Sie diesen Parameter weg, oder verwenden Sie undefined zum Abrufen der ersten Ergebnisseite.

Gibt zurück

Promise<ConversationsResult>

Ein ConversationsResult-Objekt , das eine Ergebnisseite und ein Fortsetzungstoken enthält.

Hinweise

Die Conversations-Eigenschaft des Rückgabewerts enthält eine Seite mit ConversationMembers-Objekten . Die ID jedes Objekts ist die ID einer Unterhaltung, an der der Bot an diesem Kanal teilgenommen hat. Diese Methode kann außerhalb des Kontexts einer Unterhaltung aufgerufen werden, da nur die Dienst-URL und die Anmeldeinformationen des Bots erforderlich sind.

Die Kanalbatches führen zu Seiten. Wenn die continuationToken-Eigenschaft des Ergebnisses nicht leer ist, müssen weitere Seiten abgerufen werden. Verwenden Sie das zurückgegebene Token, um die nächste Ergebnisseite abzurufen. Wenn der contextOrServiceUrl Parameter ein TurnContext ist, wird die URL des Kanalservers von contextOrServiceUrlabgerufen. Aktivität. serviceUrl.

getSignInLink(TurnContext, string, AppCredentials, string, string)

Ruft asynchron einen Anmeldelink vom Tokenserver ab, der als Teil einer SigninCard gesendet werden kann.

function getSignInLink(context: TurnContext, connectionName: string, oAuthAppCredentials?: AppCredentials, userId?: string, finalRedirect?: string): Promise<string>

Parameter

context: TurnContext

Das Kontextobjekt für den Turn.

connectionName: string

Der Name der zu verwendenden Authentifizierungsverbindung.

oAuthAppCredentials: AppCredentials

AppCredentials for OAuth.

userId: string

Die Benutzer-ID, die dem Token zugeordnet wird.

finalRedirect: string

Die endgültige URL, an die der OAuth-Flow weitergeleitet wird.

Gibt zurück

Promise<string>

getSignInLink(TurnContext, string, CoreAppCredentials, string, string)

function getSignInLink(context: TurnContext, connectionName: string, oAuthAppCredentials?: CoreAppCredentials, userId?: string, finalRedirect?: string): Promise<string>

Parameter

context: TurnContext

connectionName: string

oAuthAppCredentials: CoreAppCredentials

userId: string

finalRedirect: string

Gibt zurück

Promise<string>

getSignInResource(TurnContext, string, string, string, CoreAppCredentials)

Rufen Sie asynchron die unformatierte Anmelderessource ab, die für die Anmeldung an den Benutzer gesendet werden soll.

function getSignInResource(context: TurnContext, connectionName: string, userId?: string, finalRedirect?: string, appCredentials?: CoreAppCredentials): Promise<SignInUrlResponse>

Parameter

context: TurnContext

Das Kontextobjekt für den Turn.

connectionName: string

Der Name der zu verwendenden Authentifizierungsverbindung.

userId: string

Die Benutzer-ID, die dem Token zugeordnet wird.

finalRedirect: string

Die endgültige URL, an die der OAuth-Flow weitergeleitet wird.

appCredentials: CoreAppCredentials

Optional. CoreAppCredentials für OAuth.

Gibt zurück

Promise<SignInUrlResponse>

Das BotSignInGetSignInResourceResponse-Objekt .

getTokenStatus(TurnContext, string, string)

Ruft asynchron den Tokenstatus für jede konfigurierte Verbindung für den angegebenen Benutzer ab.

function getTokenStatus(context: TurnContext, userId?: string, includeFilter?: string): Promise<TokenStatus[]>

Parameter

context: TurnContext

Das Kontextobjekt für den Turn.

userId: string

Optional. Falls vorhanden, die ID des Benutzers, für den der Tokenstatus abgerufen werden soll. Andernfalls wird die ID des Benutzers verwendet, der die aktuelle Aktivität gesendet hat.

includeFilter: string

Optional. Eine durch Trennzeichen getrennte Liste von Verbindungen, die eingeschlossen werden sollen. Falls vorhanden, schränkt der includeFilter Parameter die von dieser Methode zurückgegebenen Token ein.

Gibt zurück

Promise<TokenStatus[]>

Die abgerufenen TokenStatus-Objekte .

getTokenStatus(TurnContext, string, string, CoreAppCredentials)

function getTokenStatus(context: TurnContext, userId?: string, includeFilter?: string, oAuthAppCredentials?: CoreAppCredentials): Promise<TokenStatus[]>

Parameter

context: TurnContext

userId: string

includeFilter: string

oAuthAppCredentials: CoreAppCredentials

Gibt zurück

Promise<TokenStatus[]>

getUserToken(TurnContext, string, string)

Versucht asynchron, das Token für einen Benutzer abzurufen, der sich in einem Anmeldeflow befindet.

function getUserToken(context: TurnContext, connectionName: string, magicCode?: string): Promise<TokenResponse>

Parameter

context: TurnContext

Das Kontextobjekt für den Turn.

connectionName: string

Der Name der zu verwendenden Authentifizierungsverbindung.

magicCode: string

Optional. Der vom Benutzer eingegebene Validierungscode.

Gibt zurück

Promise<TokenResponse>

Ein TokenResponse-Objekt , das das Benutzertoken enthält.

getUserToken(TurnContext, string, string, CoreAppCredentials)

function getUserToken(context: TurnContext, connectionName: string, magicCode?: string, oAuthAppCredentials?: CoreAppCredentials): Promise<TokenResponse>

Parameter

context: TurnContext

connectionName: string

magicCode: string

oAuthAppCredentials: CoreAppCredentials

Gibt zurück

Promise<TokenResponse>

process(Request, INodeSocket, INodeBuffer, (context: TurnContext) => Promise<void>)

Behandeln Sie eine Websocketverbindung, indem Sie eine Logikfunktion auf jede Streaminganforderung anwenden.

function process(req: Request, socket: INodeSocket, head: INodeBuffer, logic: (context: TurnContext) => Promise<void>): Promise<void>

Parameter

req: Request

Eine eingehende HTTP-Anforderung

socket: INodeSocket

Das entsprechende INodeSocket

head: INodeBuffer

Der entsprechende INodeBuffer

logic: (context: TurnContext) => Promise<void>

Die anzuwendende Logikfunktion

Gibt zurück

Promise<void>

eine Zusage, die den asynchronen Vorgang darstellt.

process(Request, Response, (context: TurnContext) => Promise<void>)

Verarbeiten Sie eine Webanforderung, indem Sie eine Logikfunktion anwenden.

function process(req: Request, res: Response, logic: (context: TurnContext) => Promise<void>): Promise<void>

Parameter

req: Request

Eine eingehende HTTP-Anforderung

res: Response

Die entsprechende HTTP-Antwort

logic: (context: TurnContext) => Promise<void>

Die anzuwendende Logikfunktion

Gibt zurück

Promise<void>

eine Zusage, die den asynchronen Vorgang darstellt.

processActivity(WebRequest, WebResponse, (context: TurnContext) => Promise<any>)

Erstellt asynchron einen Turnkontext und führt die Middlewarepipeline für eine eingehende Aktivität aus.

function processActivity(req: WebRequest, res: WebResponse, logic: (context: TurnContext) => Promise<any>): Promise<void>

Parameter

req: WebRequest

Ein Express- oder Restify-Formatanforderungsobjekt.

res: WebResponse

Ein Express- oder Restify-Formatantwortobjekt.

logic: (context: TurnContext) => Promise<any>

Die Funktion, die am Ende der Middlewarepipeline aufgerufen werden soll.

Gibt zurück

Promise<void>

Hinweise

Dies ist die wichtigste Art und Weise, wie ein Bot eingehende Nachrichten empfängt und eine Wendung in der Unterhaltung definiert. Diese Methode:

Analysiert und authentifiziert eine eingehende Anforderung.
- Die Aktivität wird aus dem Textkörper der eingehenden Anforderung gelesen. Ein Fehler wird zurückgegeben, wenn die Aktivität nicht analysiert werden kann.
- Die Identität des Absenders wird entweder als Emulator oder als gültiger Microsoft-Server mithilfe des Bots appId und appPasswordauthentifiziert. Die Anforderung wird abgelehnt, wenn die Identität des Absenders nicht überprüft wird.
Erstellt ein TurnContext-Objekt für die empfangene Aktivität.
- Dieses Objekt wird mit einem widerrufbaren Proxy umschlossen.
- Wenn diese Methode abgeschlossen ist, wird der Proxy widerrufen.
Sendet den Turnkontext über die Middlewarepipeline des Adapters.
Sendet den Turnkontext an die logic Funktion.
- Der Bot kann zu diesem Zeitpunkt zusätzliches Routing oder verarbeitung durchführen. Das Zurückgeben einer Zusage (oder das Bereitstellen eines Handlers async ) führt dazu, dass der Adapter auf den Abschluss aller asynchronen Vorgänge wartet.
- Nach Abschluss der logic Funktion wird die von der Middleware eingerichtete Versprechenskette aufgelöst.

Tipp

Wenn der Fehler TypeError: Cannot perform 'set' on a proxy that has been revoked in der Konsolenausgabe Ihres Bots angezeigt wird, besteht die wahrscheinliche Ursache darin, dass eine asynchrone Funktion verwendet wurde, ohne das await Schlüsselwort zu verwenden. Stellen Sie sicher, dass alle asynchronen Funktionen verwendet werden warten!

Middleware kann eine Kurve kurzschließen . Wenn dies geschieht, wird die nachfolgende Middleware und die logic Funktion nicht aufgerufen. Alle Middleware vor diesem Punkt werden jedoch noch bis zur Fertigstellung ausgeführt. Weitere Informationen zur Middlewarepipeline finden Sie in den Artikeln zur Funktionsweise von Bots und Middleware . Verwenden Sie die use-Methode des Adapters, um dem Adapter Middleware hinzuzufügen.

Beispiel:

server.post('/api/messages', (req, res) => {
   // Route received request to adapter for processing
   adapter.processActivity(req, res, async (context) => {
       // Process any messages received
       if (context.activity.type === ActivityTypes.Message) {
           await context.sendActivity(`Hello World`);
       }
   });
});

processActivityDirect(Activity, (context: TurnContext) => Promise<any>)

Erstellt asynchron einen Turnkontext und führt die Middlewarepipeline für eine eingehende Aktivität aus.

function processActivityDirect(activity: Activity, logic: (context: TurnContext) => Promise<any>): Promise<void>

Parameter

activity: Activity

Die zu verarbeitende Aktivität.

logic: (context: TurnContext) => Promise<any>

Die Funktion, die am Ende der Middlewarepipeline aufgerufen werden soll.

Gibt zurück

Promise<void>

Hinweise

Dies ist die wichtigste Art und Weise, wie ein Bot eingehende Nachrichten empfängt und eine Wendung in der Unterhaltung definiert. Diese Methode:

Erstellt ein TurnContext-Objekt für die empfangene Aktivität.
- Dieses Objekt wird mit einem widerrufbaren Proxy umschlossen.
- Wenn diese Methode abgeschlossen ist, wird der Proxy widerrufen.
Sendet den Turnkontext über die Middlewarepipeline des Adapters.
Sendet den Turnkontext an die logic Funktion.
- Der Bot kann zu diesem Zeitpunkt zusätzliches Routing oder verarbeitung durchführen. Das Zurückgeben einer Zusage (oder das Bereitstellen eines Handlers async ) führt dazu, dass der Adapter auf den Abschluss aller asynchronen Vorgänge wartet.
- Nach Abschluss der logic Funktion wird die von der Middleware eingerichtete Versprechenskette aufgelöst.

processRequest(IReceiveRequest)

Überprüft die Gültigkeit der Anforderung und versucht, ihr den richtigen virtuellen Endpunkt zuzuordnen. Anschließend wird eine Antwort generiert und bei Bedarf zurückgegeben.

function processRequest(request: IReceiveRequest): Promise<StreamingResponse>

Parameter

request: IReceiveRequest

Eine ReceiveRequest aus dem verbundenen Kanal.

Gibt zurück

Promise<StreamingResponse>

Eine Vom BotAdapter erstellte Antwort, die an den Client gesendet werden soll, der die Anforderung ausgelöst hat.

sendActivities(TurnContext, Partial<Activity>[])

Sendet asynchron eine Reihe ausgehender Aktivitäten an einen Kanalserver. Diese Methode unterstützt das Framework und soll nicht direkt für Ihren Code aufgerufen werden. Verwenden Sie die sendActivity - oder sendActivities-Methode des Turnkontexts aus Ihrem Botcode.

function sendActivities(context: TurnContext, activities: Partial<Activity>[]): Promise<ResourceResponse[]>

Parameter

context: TurnContext

Das Kontextobjekt für den Turn.

activities: Partial<Activity>[]

Die zu sendenden Aktivitäten.

Gibt zurück

Promise<ResourceResponse[]>

Ein Array von ResourceResponse

Hinweise

Die Aktivitäten werden nacheinander in der Reihenfolge gesendet, in der sie empfangen werden. Für jede gesendete Aktivität wird ein Antwortobjekt zurückgegeben. Für message Aktivitäten enthält dies die ID der übermittelten Nachricht.

signOutUser(TurnContext, string, string)

Melden Sie den Benutzer asynchron vom Tokenserver ab.

function signOutUser(context: TurnContext, connectionName?: string, userId?: string): Promise<void>

Parameter

context: TurnContext

Das Kontextobjekt für den Turn.

connectionName: string

Der Name der zu verwendenden Authentifizierungsverbindung.

userId: string

Die ID des Benutzers, der sich abmelden soll.

Gibt zurück

Promise<void>

signOutUser(TurnContext, string, string, CoreAppCredentials)

function signOutUser(context: TurnContext, connectionName?: string, userId?: string, oAuthAppCredentials?: CoreAppCredentials): Promise<void>

Parameter

context: TurnContext

connectionName: string

userId: string

oAuthAppCredentials: CoreAppCredentials

Gibt zurück

Promise<void>

updateActivity(TurnContext, Partial<Activity>)

Ersetzt asynchron eine vorherige Aktivität durch eine aktualisierte Version. Diese Schnittstelle unterstützt das Framework und soll nicht direkt für Ihren Code aufgerufen werden. Verwenden Sie TurnContext.updateActivity , um eine Aktivität aus Ihrem Botcode zu aktualisieren.

function updateActivity(context: TurnContext, activity: Partial<Activity>): Promise<ResourceResponse | void>

Parameter

context: TurnContext

Das Kontextobjekt für den Turn.

activity: Partial<Activity>

Die aktualisierte Version der zu ersetzenden Aktivität.

Gibt zurück

Promise<ResourceResponse | void>

Ein Promise , der die ResourceResponse für den Vorgang darstellt.

Hinweise

Nicht alle Kanäle unterstützen diesen Vorgang. Für Kanäle, die dies nicht der Fall ist, löst dieser Aufruf möglicherweise eine Ausnahme aus.

useNamedPipe((context: TurnContext) => Promise<any>, string, number, () => void)

Verbindet den Handler mit einem Named Pipe-Server und beginnt mit dem Lauschen auf eingehende Anforderungen.

function useNamedPipe(logic: (context: TurnContext) => Promise<any>, pipeName?: string, retryCount?: number, onListen?: () => void): Promise<void>

Parameter

logic: (context: TurnContext) => Promise<any>

Die Logik, die eingehende Anforderungen verarbeitet.

pipeName: string

Der Name der benannten Pipe, die beim Erstellen des Servers verwendet werden soll.

retryCount: number

Anzahl der Versuche, ein- und ausgehende Pipe zu binden

onListen: () => void

Optionaler Rückruf, der einmal ausgelöst wird, wenn der Server sowohl ein- als auch ausgehende Pipe lauscht

Gibt zurück

Promise<void>

useWebSocket(WebRequest, INodeSocket, INodeBuffer, (context: TurnContext) => Promise<any>)

Verarbeiten Sie die anfängliche Anforderung, um eine langlebige Verbindung über einen Streamingserver herzustellen.

function useWebSocket(req: WebRequest, socket: INodeSocket, head: INodeBuffer, logic: (context: TurnContext) => Promise<any>): Promise<void>

Parameter

req: WebRequest

Die Verbindungsanforderung.

socket: INodeSocket

Die unformatierte Socketverbindung zwischen bot (Server) und Kanal/Aufrufer (Client).

head: INodeBuffer

Das erste Paket des aktualisierten Datenstroms.

logic: (context: TurnContext) => Promise<any>

Die Logik, die eingehende Streaminganforderungen für die Lebensdauer der WebSocket-Verbindung verarbeitet.

Gibt zurück

Promise<void>

Details zur geerbten Methode

continueConversationAsync(ClaimsIdentity, Partial<ConversationReference>, (context: TurnContext) => Promise<void>)

Setzt eine Unterhaltung mit einem Benutzer asynchron fort, möglicherweise nach einiger Zeit.

function continueConversationAsync(claimsIdentity: ClaimsIdentity, reference: Partial<ConversationReference>, logic: (context: TurnContext) => Promise<void>): Promise<void>

Parameter

claimsIdentity: ClaimsIdentity

Eine ClaimsIdentity für die Unterhaltung.

reference: Partial<ConversationReference>

Eine teilweise ConversationReference für die Unterhaltung, die fortgesetzt werden soll.

logic: (context: TurnContext) => Promise<void>

Die asynchrone Methode, die aufgerufen werden soll, nachdem die Adaptermiddleware ausgeführt wurde.

Gibt zurück

Promise<void>

Eine Zusage, die den asynchronen Vorgang darstellt

Geerbt von BotAdapter.continueConversationAsync

continueConversationAsync(ClaimsIdentity, Partial<ConversationReference>, string, (context: TurnContext) => Promise<void>)

Setzt eine Unterhaltung mit einem Benutzer asynchron fort, möglicherweise nach einiger Zeit.

function continueConversationAsync(claimsIdentity: ClaimsIdentity, reference: Partial<ConversationReference>, audience: string, logic: (context: TurnContext) => Promise<void>): Promise<void>

Parameter

claimsIdentity: ClaimsIdentity

Eine ClaimsIdentity für die Unterhaltung.

reference: Partial<ConversationReference>

Eine teilweise ConversationReference für die Unterhaltung, die fortgesetzt werden soll.

audience: string

Ein Wert, der den Empfänger der proaktiven Nachricht angibt.

logic: (context: TurnContext) => Promise<void>

Die asynchrone Methode, die aufgerufen werden soll, nachdem die Adaptermiddleware ausgeführt wurde.

Gibt zurück

Promise<void>

Eine Zusage, die den asynchronen Vorgang darstellt

Geerbt von BotAdapter.continueConversationAsync

continueConversationAsync(string, Partial<ConversationReference>, (context: TurnContext) => Promise<void>)

Setzt eine Unterhaltung mit einem Benutzer asynchron fort, möglicherweise nach einiger Zeit.

function continueConversationAsync(botAppId: string, reference: Partial<ConversationReference>, logic: (context: TurnContext) => Promise<void>): Promise<void>

Parameter

botAppId: string

Die Anwendungs-ID des Bots. Dieser Parameter wird in den Adaptern mit nur einem Mandanten (Konsole, Test usw.) ignoriert, ist aber für den mehrinstanzenfähigen BotFrameworkAdapter wichtig.

reference: Partial<ConversationReference>

Eine teilweise ConversationReference für die Unterhaltung, die fortgesetzt werden soll.

logic: (context: TurnContext) => Promise<void>

Die asynchrone Methode, die aufgerufen werden soll, nachdem die Adaptermiddleware ausgeführt wurde.

Gibt zurück

Promise<void>

Eine Zusage, die den asynchronen Vorgang darstellt

Geerbt von BotAdapter.continueConversationAsync

createConversationAsync(string, string, string, string, ConversationParameters, (context: TurnContext) => Promise<void>)

Erstellt eine Unterhaltung im angegebenen Kanal.

function createConversationAsync(_botAppId: string, _channelId: string, _serviceUrl: string, _audience: string, _conversationParameters: ConversationParameters, _logic: (context: TurnContext) => Promise<void>): Promise<void>

Parameter

_botAppId: string

Die Anwendungs-ID des Bots.

_channelId: string

Die ID für den Kanal.

_serviceUrl: string

Die ID für den Kanal.

_audience: string

Die Zielgruppe für den Connector.

_conversationParameters: ConversationParameters

Die Unterhaltungsinformationen, die zum Erstellen der Unterhaltung verwendet werden sollen

_logic: (context: TurnContext) => Promise<void>

Die Methode, die für den resultierenden Bot turn aufgerufen werden soll.

Gibt zurück

Promise<void>

Eine Zusage, die den asynchronen Vorgang darstellt

Hinweise

Um eine Unterhaltung zu starten, muss Ihr Bot seine Kontoinformationen und die Kontoinformationen des Benutzers in diesem Kanal kennen. Die meisten _channels nur das Initiieren einer Direkten Nachrichtenunterhaltung (nicht in Gruppen) unterstützen.

Der Adapter versucht, eine neue Konversation im Kanal zu erstellen, und sendet dann eine conversationUpdate Aktivität über seine Middlewarepipeline an die Logikmethode.

Wenn die Unterhaltung mit den angegebenen Benutzern eingerichtet wird, enthält die ID der Konversation der Aktivität die ID der neuen Unterhaltung.

Geerbt von BotAdapter.createConversationAsync

use((context: TurnContext, next: () => Promise<void>) => Promise<void> | Middleware[])

Fügt der Pipeline des Adapters Middleware hinzu.

function use(middlewares: (context: TurnContext, next: () => Promise<void>) => Promise<void> | Middleware[]): this

Parameter

middlewares: (context: TurnContext, next: () => Promise<void>) => Promise<void> | Middleware[]

Die hinzuzufügenden Middleware- oder Middlewarehandler.

Gibt zurück

this

Das aktualisierte Adapterobjekt.

Hinweise

Middleware wird dem Adapter zur Initialisierungszeit hinzugefügt. Bei jedem Turn ruft der Adapter seine Middleware in der Reihenfolge auf, in der Sie sie hinzugefügt haben.

Geerbt von BotAdapter.use

Freigeben über

BotFrameworkAdapter class

Konstruktoren

Eigenschaften

Geerbte Eigenschaften

Methoden

Geerbte Methoden

Details zum Konstruktor

BotFrameworkAdapter(Partial<BotFrameworkAdapterSettings>)

Parameter

Hinweise

Details zur Eigenschaft

isStreamingConnectionOpen

Eigenschaftswert

TokenApiClientCredentialsKey

Eigenschaftswert

Geerbte Eigenschaftsdetails

BotIdentityKey

Eigenschaftswert

ConnectorClientKey

Eigenschaftswert

OAuthScopeKey

Eigenschaftswert

onTurnError

Eigenschaftswert

Details zur Methode

continueConversation(Partial<ConversationReference>, (context: TurnContext) => Promise<void>)

Parameter

Gibt zurück

Hinweise

continueConversation(Partial<ConversationReference>, string, (context: TurnContext) => Promise<void>)

Parameter

Gibt zurück

createConnectorClient(string)

Parameter

Gibt zurück

Hinweise

createConnectorClientWithIdentity(string, ClaimsIdentity)

Parameter

Gibt zurück

Hinweise

createConnectorClientWithIdentity(string, ClaimsIdentity, string)

Parameter

Gibt zurück

Hinweise

createConversation(Partial<ConversationReference>, (context: TurnContext) => Promise<void>)

Parameter

Gibt zurück

createConversation(Partial<ConversationReference>, Partial<ConversationParameters>, (context: TurnContext) => Promise<void>)

Parameter

Gibt zurück

deleteActivity(TurnContext, Partial<ConversationReference>)

Parameter

Gibt zurück

Hinweise

deleteConversationMember(TurnContext, string)

Parameter

Gibt zurück

Hinweise

emulateOAuthCards(TurnContext | string, boolean)

Parameter

Gibt zurück

Hinweise

exchangeToken(TurnContext, string, string, TokenExchangeRequest, CoreAppCredentials)

Parameter

Gibt zurück

getAadTokens(TurnContext, string, string[])

Parameter

Gibt zurück

getAadTokens(TurnContext, string, string[], CoreAppCredentials)

Parameter

Gibt zurück

getActivityMembers(TurnContext, string)

Parameter

Gibt zurück

Hinweise

getConversationMembers(TurnContext)

Parameter

Gibt zurück

Hinweise