BotFrameworkAdapter class

Référence

Paquet:: botbuilder

Avertissement

Cette API est à présent déconseillée.

Use CloudAdapter instead.

Extends: BotAdapter

Constructeurs

BotFrameworkAdapter(Partial<BotFrameworkAdapterSettings>)

Crée une instance de la classe BotFrameworkAdapter .

Propriétés

isStreamingConnectionOpen	Utilisé dans les contextes de streaming pour vérifier si la connexion de streaming est toujours ouverte pour que le bot envoie des activités.
TokenApiClientCredentialsKey

Propriétés héritées

BotIdentityKey
ConnectorClientKey
OAuthScopeKey
onTurnError

Méthodes

continueConversation(Partial<ConversationReference>, (context: TurnContext) => Promise<void>)	Reprend de façon asynchrone une conversation avec un utilisateur, peut-être après un certain temps.
continueConversation(Partial<ConversationReference>, string, (context: TurnContext) => Promise<void>)	Reprend de façon asynchrone une conversation avec un utilisateur, peut-être après un certain temps.
createConnectorClient(string)	Crée un client de connecteur.
createConnectorClientWithIdentity(string, ClaimsIdentity)	Créez un ConnectorClient avec un ClaimsIdentity.
createConnectorClientWithIdentity(string, ClaimsIdentity, string)	Créez un ConnectorClient avec un ClaimsIdentity et une audience explicite.
createConversation(Partial<ConversationReference>, (context: TurnContext) => Promise<void>)	Crée et démarre de manière asynchrone une conversation avec un utilisateur sur un canal.
createConversation(Partial<ConversationReference>, Partial<ConversationParameters>, (context: TurnContext) => Promise<void>)	Crée et démarre de manière asynchrone une conversation avec un utilisateur sur un canal.
deleteActivity(TurnContext, Partial<ConversationReference>)	Supprime de façon asynchrone une activité existante. Cette interface prend en charge le framework et n’est pas destinée à être appelée directement pour votre code. Utilisez TurnContext.deleteActivity pour supprimer une activité de votre code de bot.
deleteConversationMember(TurnContext, string)	Supprime de façon asynchrone un membre de la conversation actuelle.
emulateOAuthCards(TurnContext \| string, boolean)	Envoie de façon asynchrone une carte OAuth émulée pour un canal. Cette méthode prend en charge l’infrastructure et n’est pas destinée à être appelée directement pour votre code.
exchangeToken(TurnContext, string, string, TokenExchangeRequest, CoreAppCredentials)	Effectue de manière asynchrone une opération d’échange de jetons, par exemple pour l’authentification unique.
getAadTokens(TurnContext, string, string[])	Déconnecte de façon asynchrone l’utilisateur du serveur de jetons.
getAadTokens(TurnContext, string, string[], CoreAppCredentials)
getActivityMembers(TurnContext, string)	Répertorie de manière asynchrone les membres d’une activité donnée.
getConversationMembers(TurnContext)	Répertorie de façon asynchrone les membres de la conversation actuelle.
getConversations(TurnContext \| string, string)	Pour le canal spécifié, obtient de manière asynchrone une page des conversations auxquelles ce bot a participé.
getSignInLink(TurnContext, string, AppCredentials, string, string)	Obtient de manière asynchrone un lien de connexion à partir du serveur de jetons qui peut être envoyé dans le cadre d’une signinCard.
getSignInLink(TurnContext, string, CoreAppCredentials, string, string)
getSignInResource(TurnContext, string, string, string, CoreAppCredentials)	Obtenez de manière asynchrone la ressource de connexion brute à envoyer à l’utilisateur pour la connexion.
getTokenStatus(TurnContext, string, string)	Récupère de manière asynchrone l’état du jeton pour chaque connexion configurée pour l’utilisateur donné.
getTokenStatus(TurnContext, string, string, CoreAppCredentials)
getUserToken(TurnContext, string, string)	Tente de manière asynchrone de récupérer le jeton d’un utilisateur qui se trouve dans un flux de connexion.
getUserToken(TurnContext, string, string, CoreAppCredentials)
process(Request, INodeSocket, INodeBuffer, (context: TurnContext) => Promise<void>)	Gérez une connexion de socket web en appliquant une fonction logique à chaque demande de streaming.
process(Request, Response, (context: TurnContext) => Promise<void>)	Traiter une requête web en appliquant une fonction logique.
processActivity(WebRequest, WebResponse, (context: TurnContext) => Promise<any>)	Crée de manière asynchrone un contexte de tour et exécute le pipeline d’intergiciel pour une activité entrante.
processActivityDirect(Activity, (context: TurnContext) => Promise<any>)	Crée de manière asynchrone un contexte de tour et exécute le pipeline d’intergiciel pour une activité entrante.
processRequest(IReceiveRequest)	Vérifie la validité de la demande et tente de la mapper le point de terminaison virtuel approprié, puis génère et retourne une réponse, le cas échéant.
sendActivities(TurnContext, Partial<Activity>[])	Envoie de façon asynchrone un ensemble d’activités sortantes à un serveur de canal. Cette méthode prend en charge l’infrastructure et n’est pas destinée à être appelée directement pour votre code. Utilisez la méthode sendActivity ou sendActivities du contexte de tour à partir de votre code de bot.
signOutUser(TurnContext, string, string)	Déconnecte de façon asynchrone l’utilisateur du serveur de jetons.
signOutUser(TurnContext, string, string, CoreAppCredentials)
updateActivity(TurnContext, Partial<Activity>)	Remplace de manière asynchrone une activité précédente par une version mise à jour. Cette interface prend en charge le framework et n’est pas destinée à être appelée directement pour votre code. Utilisez TurnContext.updateActivity pour mettre à jour une activité à partir du code de votre bot.
useNamedPipe((context: TurnContext) => Promise<any>, string, number, () => void)	Connecte le gestionnaire à un serveur de canal nommé et commence à écouter les demandes entrantes.
useWebSocket(WebRequest, INodeSocket, INodeBuffer, (context: TurnContext) => Promise<any>)	Traitez la demande initiale pour établir une connexion de longue durée via un serveur de streaming.

Méthodes héritées

continueConversationAsync(ClaimsIdentity, Partial<ConversationReference>, (context: TurnContext) => Promise<void>)	Reprend de façon asynchrone une conversation avec un utilisateur, peut-être après un certain temps.
continueConversationAsync(ClaimsIdentity, Partial<ConversationReference>, string, (context: TurnContext) => Promise<void>)	Reprend de façon asynchrone une conversation avec un utilisateur, peut-être après un certain temps.
continueConversationAsync(string, Partial<ConversationReference>, (context: TurnContext) => Promise<void>)	Reprend de façon asynchrone une conversation avec un utilisateur, peut-être après un certain temps.
createConversationAsync(string, string, string, string, ConversationParameters, (context: TurnContext) => Promise<void>)	Crée une conversation sur le canal spécifié.
use((context: TurnContext, next: () => Promise<void>) => Promise<void> \| Middleware[])	Ajoute un intergiciel (middleware) au pipeline de l’adaptateur.

Détails du constructeur

BotFrameworkAdapter(Partial<BotFrameworkAdapterSettings>)

Crée une instance de la classe BotFrameworkAdapter .

new BotFrameworkAdapter(settings?: Partial<BotFrameworkAdapterSettings>)

Paramètres

settings: Partial<BotFrameworkAdapterSettings>

facultatif. Paramètres à utiliser pour cette instance d’adaptateur.

Remarques

Si le settings paramètre n’inclut pas les valeurs channelService ou openIdMetadata , le constructeur vérifie les variables d’environnement du processus pour ces valeurs. Ces valeurs peuvent être définies lorsqu’un bot est approvisionné sur Azure et, le cas échéant, elles sont nécessaires pour que le bot fonctionne correctement dans le cloud global ou dans un cloud national.

La classe BotFrameworkAdapterSettings définit les paramètres d’adaptateur disponibles.

Détails de la propriété

isStreamingConnectionOpen

Utilisé dans les contextes de streaming pour vérifier si la connexion de streaming est toujours ouverte pour que le bot envoie des activités.

boolean isStreamingConnectionOpen

Valeur de propriété

boolean

True si la connexion de streaming est ouverte, sinon false.

TokenApiClientCredentialsKey

TokenApiClientCredentialsKey: symbol

Valeur de propriété

symbol

Détails de la propriété héritée

BotIdentityKey

BotIdentityKey: symbol

Valeur de propriété

symbol

Hérité de BotAdapter.BotIdentityKey

ConnectorClientKey

ConnectorClientKey: symbol

Valeur de propriété

symbol

Hérité de BotAdapter.ConnectorClientKey

OAuthScopeKey

OAuthScopeKey: symbol

Valeur de propriété

symbol

Hérité de BotAdapter.OAuthScopeKey

onTurnError

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

Valeur de propriété

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

Hérité de BotAdapter.onTurnError

Détails de la méthode

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

Reprend de façon asynchrone une conversation avec un utilisateur, peut-être après un certain temps.

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

Paramètres

reference: Partial<ConversationReference>

Référence à la conversation à poursuivre.

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

Méthode asynchrone à appeler après l’exécution de l’intergiciel de l’adaptateur.

Retours

Promise<void>

Remarques

Il s’agit souvent d’une notification proactive. Le bot peut envoyer de manière proactive un message à une conversation ou à un utilisateur sans attendre un message entrant. Par exemple, un bot peut utiliser cette méthode pour envoyer des notifications ou des coupons à un utilisateur.

Pour envoyer un message proactif :

Enregistrez une copie d’une conversationReference à partir d’une activité entrante. Par exemple, vous pouvez stocker la référence de conversation dans une base de données.
Appelez cette méthode pour reprendre la conversation ultérieurement. Utilisez la référence enregistrée pour accéder à la conversation.
En cas de réussite, l’adaptateur génère un objet TurnContext et appelle le gestionnaire de fonction logic . Utilisez la logic fonction pour envoyer le message proactif.

Pour copier la référence à partir d’une activité entrante dans la conversation, utilisez la méthode TurnContext.getConversationReference .

Cette méthode est similaire à la méthode processActivity . L’adaptateur crée un TurnContext et l’achemine via son intergiciel avant d’appeler le logic gestionnaire. L’activité créée aura le type « event » et le nom « continueConversation ».

Par exemple :

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

Reprend de façon asynchrone une conversation avec un utilisateur, peut-être après un certain temps.

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

Paramètres

reference: Partial<ConversationReference>

(xref:botframework-schema. ConversationReference) de la conversation à poursuivre.

oAuthScope: string

Destinataire prévu des activités envoyées ou de la fonction à appeler pour poursuivre la conversation.

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

facultatif. Méthode asynchrone à appeler après l’exécution de l’intergiciel de l’adaptateur.

Retours

Promise<void>

createConnectorClient(string)

Crée un client de connecteur.

function createConnectorClient(serviceUrl: string): ConnectorClient

Paramètres

serviceUrl: string

URL du service du client.

Retours

ConnectorClient

Instance ConnectorClient .

Remarques

Remplacez ce paramètre dans une classe dérivée pour créer un client de connecteur fictif pour les tests unitaires.

createConnectorClientWithIdentity(string, ClaimsIdentity)

Créez un ConnectorClient avec un ClaimsIdentity.

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

Paramètres

serviceUrl: string

URL du service du client.

identity: ClaimsIdentity

Claimsidentity

Retours

Promise<ConnectorClient>

Remarques

Si ClaimsIdentity contient les revendications d’une demande skills, créez un ConnectorClient à utiliser avec Skills. Dérive l’audience correcte de la propriété ClaimsIdentity ou des informations d’identification de l’instance.

createConnectorClientWithIdentity(string, ClaimsIdentity, string)

Créez un ConnectorClient avec un ClaimsIdentity et une audience explicite.

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

Paramètres

serviceUrl: string

URL du service du client.

identity: ClaimsIdentity

Claimsidentity

audience: string

Destinataire des messages de ConnectorClient. Normalement, le service de canal Bot Framework ou l’AppId d’un autre bot.

Retours

Promise<ConnectorClient>

Remarques

Si l’audience supprimée n’est pas une chaîne de longueur différente de zéro, l’audience est dérivée de la propriété ClaimsIdentity ou des informations d’identification de l’instance.

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

Crée et démarre de manière asynchrone une conversation avec un utilisateur sur un canal.

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

Paramètres

reference: Partial<ConversationReference>

Référence pour la conversation à créer.

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

Méthode asynchrone à appeler après l’exécution de l’intergiciel de l’adaptateur.

Retours

Promise<void>

promesse représentant l’opération asynchrone

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

Crée et démarre de manière asynchrone une conversation avec un utilisateur sur un canal.

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

Paramètres

reference: Partial<ConversationReference>

Référence pour la conversation à créer.

parameters: Partial<ConversationParameters>

Paramètres utilisés lors de la création de la conversation

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

Méthode asynchrone à appeler après l’exécution de l’intergiciel de l’adaptateur.

Retours

Promise<void>

promesse représentant l’opération asynchrone

deleteActivity(TurnContext, Partial<ConversationReference>)

Supprime de façon asynchrone une activité existante. Cette interface prend en charge le framework et n’est pas destinée à être appelée directement pour votre code. Utilisez TurnContext.deleteActivity pour supprimer une activité de votre code de bot.

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

Paramètres

context: TurnContext

Objet de contexte pour le tour.

reference: Partial<ConversationReference>

Informations de référence de conversation pour l’activité à supprimer.

Retours

Promise<void>

Remarques

Tous les canaux ne prennent pas en charge cette opération. Pour les canaux qui ne le font pas, cet appel peut lever une exception.

deleteConversationMember(TurnContext, string)

Supprime de façon asynchrone un membre de la conversation actuelle.

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

Paramètres

context: TurnContext

Objet de contexte pour le tour.

memberId: string

ID du membre à supprimer de la conversation.

Retours

Promise<void>

Remarques

Supprimez les informations d’identité d’un membre de la conversation.

Tous les canaux ne prennent pas en charge cette opération. Pour les canaux qui ne le font pas, cet appel peut lever une exception.

emulateOAuthCards(TurnContext | string, boolean)

Envoie de façon asynchrone une carte OAuth émulée pour un canal. Cette méthode prend en charge l’infrastructure et n’est pas destinée à être appelée directement pour votre code.

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

Paramètres

contextOrServiceUrl: TurnContext | string

URL de l’émulateur.

emulate: boolean

true pour envoyer une carte OAuth émulée à l’émulateur ; ou false de ne pas envoyer la carte.

Retours

Promise<void>

Remarques

Lors du test d’un bot dans le Bot Framework Emulator, cette méthode peut émuler l’interaction de carte OAuth.

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

Effectue de manière asynchrone une opération d’échange de jetons, par exemple pour l’authentification unique.

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

Paramètres

context: TurnContext

Contexte de la conversation actuelle avec l’utilisateur.

connectionName: string

Nom de la connexion d’authentification à utiliser.

userId: string

ID d’utilisateur qui sera associé au jeton.

tokenExchangeRequest: TokenExchangeRequest

Les détails de la demande d’échange, soit un jeton à échanger, soit un URI à échanger.

appCredentials: CoreAppCredentials

facultatif. CoreAppCredentials pour OAuth.

Retours

Promise<TokenResponse>

getAadTokens(TurnContext, string, string[])

Déconnecte de façon asynchrone l’utilisateur du serveur de jetons.

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

Paramètres

context: TurnContext

Objet de contexte pour le tour.

connectionName: string

Nom de la connexion d’authentification à utiliser.

resourceUrls: string[]

Liste des URL de ressource pour laquelle récupérer des jetons.

Retours

Promise<[key: string]: TokenResponse>

Mappage des objets TokenResponse par URL de ressource.

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

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

Paramètres

context: TurnContext

connectionName: string

resourceUrls: string[]

oAuthAppCredentials: CoreAppCredentials

Retours

Promise<[key: string]: TokenResponse>

getActivityMembers(TurnContext, string)

Répertorie de manière asynchrone les membres d’une activité donnée.

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

Paramètres

context: TurnContext

Objet de contexte pour le tour.

activityId: string

facultatif. ID de l’activité dont vous souhaitez obtenir les membres. S’il n’est pas spécifié, l’ID d’activité actuel est utilisé.

Retours

Promise<ChannelAccount[]>

Tableau d’objets ChannelAccount pour les utilisateurs impliqués dans une activité donnée.

Remarques

Retourne un tableau d’objets ChannelAccount pour les utilisateurs impliqués dans une activité donnée.

Cela est différent de getConversationMembers en ce qu’il retourne uniquement les utilisateurs directement impliqués dans l’activité, pas tous les membres de la conversation.

getConversationMembers(TurnContext)

Répertorie de façon asynchrone les membres de la conversation actuelle.

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

Paramètres

context: TurnContext

Objet de contexte pour le tour.

Retours

Promise<ChannelAccount[]>

Tableau d’objets ChannelAccount pour tous les utilisateurs actuellement impliqués dans une conversation.

Remarques

Retourne un tableau d’objets ChannelAccount pour tous les utilisateurs actuellement impliqués dans une conversation.

Cela est différent de getActivityMembers en ce qu’il retourne tous les membres de la conversation, pas seulement ceux directement impliqués dans une activité spécifique.

getConversations(TurnContext | string, string)

Pour le canal spécifié, obtient de manière asynchrone une page des conversations auxquelles ce bot a participé.

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

Paramètres

contextOrServiceUrl: TurnContext | string

URL du serveur de canal à interroger ou objet TurnContext à partir d’une conversation sur le canal.

continuationToken: string

facultatif. Jeton de continuation de la page précédente des résultats. Omettez ce paramètre ou utilisez undefined pour récupérer la première page de résultats.

Retours

Promise<ConversationsResult>

Objet ConversationsResult contenant une page de résultats et un jeton de continuation.

Remarques

La propriété conversations de la valeur de retour contient une page d’objets ConversationMembers . L’ID de chaque objet est l’ID d’une conversation à laquelle le bot a participé sur ce canal. Cette méthode peut être appelée en dehors du contexte d’une conversation, car seules l’URL du service et les informations d’identification du bot sont requises.

Les lots de canaux donnent des pages. Si la propriété continuationToken du résultat n’est pas vide, il y a d’autres pages à obtenir. Utilisez le jeton retourné pour obtenir la page de résultats suivante. Si le contextOrServiceUrl paramètre est un TurnContext, l’URL du serveur de canal est récupérée à partir de contextOrServiceUrl. activité. serviceUrl.

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

Obtient de manière asynchrone un lien de connexion à partir du serveur de jetons qui peut être envoyé dans le cadre d’une signinCard.

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

Paramètres

context: TurnContext

Objet de contexte pour le tour.

connectionName: string

Nom de la connexion d’authentification à utiliser.

oAuthAppCredentials: AppCredentials

AppCredentials pour OAuth.

userId: string

ID d’utilisateur qui sera associé au jeton.

finalRedirect: string

URL finale vers laquelle le flux OAuth sera redirigé.

Retours

Promise<string>

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

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

Paramètres

context: TurnContext

connectionName: string

oAuthAppCredentials: CoreAppCredentials

userId: string

finalRedirect: string

Retours

Promise<string>

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

Obtenez de manière asynchrone la ressource de connexion brute à envoyer à l’utilisateur pour la connexion.

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

Paramètres

context: TurnContext

Objet de contexte pour le tour.

connectionName: string

Nom de la connexion d’authentification à utiliser.

userId: string

ID d’utilisateur qui sera associé au jeton.

finalRedirect: string

URL finale vers laquelle le flux OAuth sera redirigé.

appCredentials: CoreAppCredentials

facultatif. CoreAppCredentials pour OAuth.

Retours

Promise<SignInUrlResponse>

Objet BotSignInGetSignInResourceResponse .

getTokenStatus(TurnContext, string, string)

Récupère de manière asynchrone l’état du jeton pour chaque connexion configurée pour l’utilisateur donné.

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

Paramètres

context: TurnContext

Objet de contexte pour le tour.

userId: string

facultatif. Le cas échéant, l’ID de l’utilisateur pour lequel récupérer l’état du jeton. Sinon, l’ID de l’utilisateur qui a envoyé l’activité actuelle est utilisé.

includeFilter: string

facultatif. Liste séparée par des virgules des connexions à inclure. Le cas échéant, le includeFilter paramètre limite les jetons retournés par cette méthode.

Retours

Promise<TokenStatus[]>

Objets TokenStatus récupérés.

getTokenStatus(TurnContext, string, string, CoreAppCredentials)

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

Paramètres

context: TurnContext

userId: string

includeFilter: string

oAuthAppCredentials: CoreAppCredentials

Retours

Promise<TokenStatus[]>

getUserToken(TurnContext, string, string)

Tente de manière asynchrone de récupérer le jeton d’un utilisateur qui se trouve dans un flux de connexion.

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

Paramètres

context: TurnContext

Objet de contexte pour le tour.

connectionName: string

Nom de la connexion d’authentification à utiliser.

magicCode: string

facultatif. Code de validation entré par l’utilisateur.

Retours

Promise<TokenResponse>

Objet TokenResponse qui contient le jeton utilisateur.

getUserToken(TurnContext, string, string, CoreAppCredentials)

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

Paramètres

context: TurnContext

connectionName: string

magicCode: string

oAuthAppCredentials: CoreAppCredentials

Retours

Promise<TokenResponse>

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

Gérez une connexion de socket web en appliquant une fonction logique à chaque demande de streaming.

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

Paramètres

req: Request

Requête HTTP entrante

socket: INodeSocket

INodeSocket correspondant

head: INodeBuffer

INodeBuffer correspondant

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

Fonction logique à appliquer

Retours

Promise<void>

promesse représentant l’opération asynchrone.

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

Traiter une requête web en appliquant une fonction logique.

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

Paramètres

req: Request

Requête HTTP entrante

res: Response

Réponse HTTP correspondante

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

Fonction logique à appliquer

Retours

Promise<void>

promesse représentant l’opération asynchrone.

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

Crée de manière asynchrone un contexte de tour et exécute le pipeline d’intergiciel pour une activité entrante.

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

Paramètres

req: WebRequest

Objet de demande de style Express ou Restify.

res: WebResponse

Objet de réponse de style Express ou Restify.

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

Fonction à appeler à la fin du pipeline d’intergiciel.

Retours

Promise<void>

Remarques

Il s’agit de la principale façon dont un bot reçoit les messages entrants et définit un tour dans la conversation. Cette méthode :

Analyse et authentifie une requête entrante.
- L’activité est lue à partir du corps de la requête entrante. Une erreur est retournée si l’activité ne peut pas être analysée.
- L’identité de l’expéditeur est authentifiée en tant qu’émulateur ou serveur Microsoft valide, à l’aide des données du appId bot et appPasswordde . La demande est rejetée si l’identité de l’expéditeur n’est pas vérifiée.
Crée un objet TurnContext pour l’activité reçue.
- Cet objet est encapsulé avec un proxy révocable.
- Une fois cette méthode terminée, le proxy est révoqué.
Envoie le contexte de tour par le biais du pipeline middleware de l’adaptateur.
Envoie le contexte de tour à la logic fonction.
- Le bot peut effectuer un routage ou un traitement supplémentaire pour le moment. Le retour d’une promesse (ou la fourniture d’un async gestionnaire) entraîne l’attente de l’adaptateur jusqu’à la fin des opérations asynchrones.
- Une fois la logic fonction terminée, la chaîne de promesse configurée par le middleware est résolue.

Conseil

Si vous voyez l’erreur TypeError: Cannot perform 'set' on a proxy that has been revoked dans la sortie de la console de votre bot, la cause est probablement qu’une fonction asynchrone a été utilisée sans utiliser le await mot clé. Assurez-vous que toutes les fonctions asynchrones utilisent await!

L’intergiciel peut court-circuiter un tour. Dans ce cas, le middleware suivant et la logic fonction ne sont pas appelés ; toutefois, tous les middlewares antérieurs à ce point s’exécutent toujours jusqu’à l’achèvement. Pour plus d’informations sur le pipeline d’intergiciels, consultez les articles fonctionnement des bots et middleware . Utilisez la méthode use de l’adaptateur pour ajouter un intergiciel à l’adaptateur.

Par exemple :

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

Crée de manière asynchrone un contexte de tour et exécute le pipeline d’intergiciel pour une activité entrante.

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

Paramètres

activity: Activity

Activité à traiter.

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

Fonction à appeler à la fin du pipeline d’intergiciel.

Retours

Promise<void>

Remarques

Il s’agit de la principale façon dont un bot reçoit les messages entrants et définit un tour dans la conversation. Cette méthode :

Crée un objet TurnContext pour l’activité reçue.
- Cet objet est encapsulé avec un proxy révocable.
- Une fois cette méthode terminée, le proxy est révoqué.
Envoie le contexte de tour par le biais du pipeline d’intergiciel de l’adaptateur.
Envoie le contexte de tour à la logic fonction.
- Le bot peut effectuer un routage ou un traitement supplémentaire à ce stade. Le retour d’une promesse (ou la fourniture d’un async gestionnaire) entraîne l’attente de l’adaptateur jusqu’à la fin des opérations asynchrones.
- Une fois la logic fonction terminée, la chaîne de promesse configurée par l’intergiciel est résolue.

L’intergiciel peut court-circuiter un tour. Dans ce cas, les intergiciels suivants et la logic fonction ne sont pas appelés ; toutefois, tous les intergiciels antérieurs à ce point s’exécutent toujours jusqu’à la fin. Pour plus d’informations sur le pipeline d’intergiciels, consultez les articles fonctionnement des bots et intergiciels . Utilisez la méthode use de l’adaptateur pour ajouter un intergiciel à l’adaptateur.

processRequest(IReceiveRequest)

Vérifie la validité de la demande et tente de la mapper le point de terminaison virtuel approprié, puis génère et retourne une réponse, le cas échéant.

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

Paramètres

request: IReceiveRequest

Une demande ReceiveRequest à partir du canal connecté.

Retours

Promise<StreamingResponse>

Réponse créée par le BotAdapter à envoyer au client à l’origine de la demande.

sendActivities(TurnContext, Partial<Activity>[])

Envoie de façon asynchrone un ensemble d’activités sortantes à un serveur de canal. Cette méthode prend en charge l’infrastructure et n’est pas destinée à être appelée directement pour votre code. Utilisez la méthode sendActivity ou sendActivities du contexte de tour à partir de votre code de bot.

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

Paramètres

context: TurnContext

Objet de contexte pour le tour.

activities: Partial<Activity>[]

Activités à envoyer.

Retours

Promise<ResourceResponse[]>

Tableau de ResourceResponse

Remarques

Les activités sont envoyées les unes après les autres dans l’ordre dans lequel elles sont reçues. Un objet response est retourné pour chaque activité envoyée. Pour message les activités, il contient l’ID du message remis.

signOutUser(TurnContext, string, string)

Déconnecte de façon asynchrone l’utilisateur du serveur de jetons.

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

Paramètres

context: TurnContext

Objet de contexte pour le tour.

connectionName: string

Nom de la connexion d’authentification à utiliser.

userId: string

ID de l’utilisateur à déconnecter.

Retours

Promise<void>

signOutUser(TurnContext, string, string, CoreAppCredentials)

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

Paramètres

context: TurnContext

connectionName: string

userId: string

oAuthAppCredentials: CoreAppCredentials

Retours

Promise<void>

updateActivity(TurnContext, Partial<Activity>)

Remplace de manière asynchrone une activité précédente par une version mise à jour. Cette interface prend en charge le framework et n’est pas destinée à être appelée directement pour votre code. Utilisez TurnContext.updateActivity pour mettre à jour une activité à partir du code de votre bot.

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

Paramètres

context: TurnContext

Objet de contexte pour le tour.

activity: Partial<Activity>

Version mise à jour de l’activité à remplacer.

Retours

Promise<ResourceResponse | void>

Promise représentant resourceResponse pour l’opération.

Remarques

Tous les canaux ne prennent pas en charge cette opération. Pour les canaux qui ne le font pas, cet appel peut lever une exception.

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

Connecte le gestionnaire à un serveur de canal nommé et commence à écouter les demandes entrantes.

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

Paramètres

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

Logique qui gérera les requêtes entrantes.

pipeName: string

Nom du canal nommé à utiliser lors de la création du serveur.

retryCount: number

Nombre de tentatives de liaison de canal entrant et sortant

onListen: () => void

Rappel facultatif qui se déclenche une fois lorsque le serveur écoute à la fois sur le canal entrant et sortant

Retours

Promise<void>

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

Traitez la demande initiale pour établir une connexion de longue durée via un serveur de streaming.

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

Paramètres

req: WebRequest

Demande de connexion.

socket: INodeSocket

Connexion de socket brut entre le bot (serveur) et le canal/appelant (client).

head: INodeBuffer

Premier paquet du flux mis à niveau.

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

Logique qui gère les demandes de streaming entrantes pendant la durée de vie de la connexion WebSocket.

Retours

Promise<void>

Détails de la méthode héritée

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

Reprend de façon asynchrone une conversation avec un utilisateur, peut-être après un certain temps.

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

Paramètres

claimsIdentity: ClaimsIdentity

ClaimsIdentity pour la conversation.

reference: Partial<ConversationReference>

ConversationReference partielle à la conversation à poursuivre.

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

Méthode asynchrone à appeler après l’exécution de l’intergiciel de l’adaptateur.

Retours

Promise<void>

promesse représentant l’opération asynchrone

Hérité de BotAdapter.continueConversationAsync

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

Reprend de façon asynchrone une conversation avec un utilisateur, peut-être après un certain temps.

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

Paramètres

claimsIdentity: ClaimsIdentity

ClaimsIdentity pour la conversation.

reference: Partial<ConversationReference>

ConversationReference partielle à la conversation à poursuivre.

audience: string

Valeur qui signifie le destinataire du message proactif.

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

Méthode asynchrone à appeler après l’exécution de l’intergiciel de l’adaptateur.

Retours

Promise<void>

promesse représentant l’opération asynchrone

Hérité de BotAdapter.continueConversationAsync

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

Reprend de façon asynchrone une conversation avec un utilisateur, peut-être après un certain temps.

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

Paramètres

botAppId: string

ID d’application du bot. Ce paramètre est ignoré dans les adaptateurs à locataire unique (console, test, etc.), mais il est essentiel pour le BotFrameworkAdapter qui prend en charge les multilocataires.

reference: Partial<ConversationReference>

ConversationReference partielle à la conversation à poursuivre.

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

Méthode asynchrone à appeler après l’exécution de l’intergiciel de l’adaptateur.

Retours

Promise<void>

promesse représentant l’opération asynchrone

Hérité de BotAdapter.continueConversationAsync

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

Crée une conversation sur le canal spécifié.

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

Paramètres

_botAppId: string

ID d’application du bot.

_channelId: string

ID du canal.

_serviceUrl: string

ID du canal.

_audience: string

Audience du connecteur.

_conversationParameters: ConversationParameters

Informations de conversation à utiliser pour créer la conversation

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

Méthode à appeler pour le tour de bot résultant.

Retours

Promise<void>

Promesse qui représente l’opération asynchrone

Remarques

Pour démarrer une conversation, votre bot doit connaître ses informations de compte et les informations de compte de l’utilisateur sur ce canal. La plupart des _channels prennent uniquement en charge le lancement d’une conversation par message direct (non de groupe).

L’adaptateur tente de créer une conversation sur le canal, puis envoie une conversationUpdate activité via son pipeline d’intergiciel (middleware) à la méthode logique.

Si la conversation est établie avec les utilisateurs spécifiés, l’ID de la conversation de l’activité contient l’ID de la nouvelle conversation.

Hérité de BotAdapter.createConversationAsync

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

Ajoute un intergiciel (middleware) au pipeline de l’adaptateur.

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

Paramètres

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

Gestionnaires d’intergiciels ou d’intergiciels à ajouter.

Retours

this

Objet adaptateur mis à jour.

Remarques

L’intergiciel est ajouté à l’adaptateur au moment de l’initialisation. À chaque tour, l’adaptateur appelle son intergiciel dans l’ordre dans lequel vous l’avez ajouté.

Hérité de BotAdapter.use

Share via

BotFrameworkAdapter class

Constructeurs

Propriétés

Propriétés héritées

Méthodes

Méthodes héritées

Détails du constructeur

BotFrameworkAdapter(Partial<BotFrameworkAdapterSettings>)

Paramètres

Remarques

Détails de la propriété

isStreamingConnectionOpen

Valeur de propriété

TokenApiClientCredentialsKey

Valeur de propriété

Détails de la propriété héritée

BotIdentityKey

Valeur de propriété

ConnectorClientKey

Valeur de propriété

OAuthScopeKey

Valeur de propriété

onTurnError

Valeur de propriété

Détails de la méthode

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

Paramètres

Retours

Remarques

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

Paramètres

Retours

createConnectorClient(string)

Paramètres

Retours

Remarques

createConnectorClientWithIdentity(string, ClaimsIdentity)

Paramètres

Retours

Remarques

createConnectorClientWithIdentity(string, ClaimsIdentity, string)

Paramètres

Retours

Remarques

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

Paramètres

Retours

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

Paramètres

Retours

deleteActivity(TurnContext, Partial<ConversationReference>)

Paramètres

Retours

Remarques

deleteConversationMember(TurnContext, string)

Paramètres

Retours

Remarques

emulateOAuthCards(TurnContext | string, boolean)

Paramètres

Retours

Remarques

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

Paramètres

Retours

getAadTokens(TurnContext, string, string[])

Paramètres

Retours

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

Paramètres

Retours

getActivityMembers(TurnContext, string)

Paramètres

Retours

Remarques

getConversationMembers(TurnContext)

Paramètres

Retours

Remarques