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 diffusion en continu pour vérifier si la connexion de diffusion en continu 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, éventuellement après un certain temps.
continueConversation(Partial<ConversationReference>, string, (context: TurnContext) => Promise<void>)	Reprend de façon asynchrone une conversation avec un utilisateur, éventuellement 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 claimsIdentity et un public explicite.
createConversation(Partial<ConversationReference>, (context: TurnContext) => Promise<void>)	Crée et démarre de façon asynchrone une conversation avec un utilisateur sur un canal.
createConversation(Partial<ConversationReference>, Partial<ConversationParameters>, (context: TurnContext) => Promise<void>)	Crée et démarre de façon 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 l’infrastructure et n’est pas destinée à être appelée directement pour votre code. Utilisez TurnContext.deleteActivity pour supprimer une activité de votre code 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 façon asynchrone une opération d’échange de jetons telle que 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 façon 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 façon asynchrone une page des conversations dans lesquelles ce bot a participé.
getSignInLink(TurnContext, string, AppCredentials, string, string)	Obtient de façon asynchrone un lien de connexion à partir du serveur de jetons qui peut être envoyé dans le cadre d’un 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 façon 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 diffusion en continu.
process(Request, Response, (context: TurnContext) => Promise<void>)	Traitez une requête web en appliquant une fonction logique.
processActivity(WebRequest, WebResponse, (context: TurnContext) => Promise<any>)	Crée de façon 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 façon asynchrone un contexte de tour et exécute le pipeline d’intergiciel pour une activité entrante.
processRequest(IReceiveRequest)	Vérifie la validité de la requête et tente de la mapper le point de terminaison virtuel approprié, puis génère et retourne une réponse si nécessaire.
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 le sendActivity du contexte de tour ou méthode sendActivities à partir de votre code 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 façon asynchrone une activité précédente par une version mise à jour. Cette interface prend en charge l’infrastructure et n’est pas destinée à être appelée directement pour votre code. Utilisez TurnContext.updateActivity pour mettre à jour une activité à partir de votre code 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 diffusion en continu.

Méthodes héritées

continueConversationAsync(ClaimsIdentity, Partial<ConversationReference>, (context: TurnContext) => Promise<void>)	Reprend de façon asynchrone une conversation avec un utilisateur, éventuellement après un certain temps.
continueConversationAsync(ClaimsIdentity, Partial<ConversationReference>, string, (context: TurnContext) => Promise<void>)	Reprend de façon asynchrone une conversation avec un utilisateur, éventuellement après un certain temps.
continueConversationAsync(string, Partial<ConversationReference>, (context: TurnContext) => Promise<void>)	Reprend de façon asynchrone une conversation avec un utilisateur, éventuellement 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 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>

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

Remarques

Si le paramètre settings n’inclut pas channelService ou valeurs 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, pour que le bot fonctionne correctement dans le cloud global ou dans un cloud national.

La classe BotFrameworkAdapterSettings définit les paramètres de l’adaptateur disponible.

Détails de la propriété

isStreamingConnectionOpen

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

boolean isStreamingConnectionOpen

Valeur de propriété

boolean

True si la connexion de diffusion en continu 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ée de BotAdapter.BotIdentityKey

ConnectorClientKey

ConnectorClientKey: symbol

Valeur de propriété

symbol

héritée de BotAdapter.ConnectorClientKey

OAuthScopeKey

OAuthScopeKey: symbol

Valeur de propriété

symbol

héritée de botAdapter.OAuthScopeKey

onTurnError

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

Valeur de propriété

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

héritée 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, éventuellement 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 pour continuer.

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

Méthode asynchrone à appeler après l’exécution du middleware 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 fonctions logic. Utilisez la fonction logic 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 gestionnaire logic. L’activité créée a un type de de « event » et un nom de de « 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, éventuellement 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 de toutes les activités envoyées ou de la fonction à appeler pour poursuivre la conversation.

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

Optionnel. Méthode asynchrone à appeler après l’exécution du middleware 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 cela 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 requête Skills, créez un ConnectorClient à utiliser avec Skills. Dérive l’audience correcte de ClaimsIdentity ou de la propriété d’informations d’identification de l’instance.

createConnectorClientWithIdentity(string, ClaimsIdentity, string)

Créez un ConnectorClient avec claimsIdentity et un public 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 rogné 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 de la propriété d’informations d’identification de l’instance.

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

Crée et démarre de façon 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 du middleware de l’adaptateur.

Retours

Promise<void>

une promesse représentant l’opération asynchrone

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

Crée et démarre de façon 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 du middleware de l’adaptateur.

Retours

Promise<void>

une promesse représentant l’opération asynchrone

deleteActivity(TurnContext, Partial<ConversationReference>)

Supprime de façon asynchrone une activité existante. Cette interface prend en charge l’infrastructure et n’est pas destinée à être appelée directement pour votre code. Utilisez TurnContext.deleteActivity pour supprimer une activité de votre code 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 sur la 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 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 l’émulateur Bot Framework, cette méthode peut émuler l’interaction de carte OAuth.

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

Effectue de façon asynchrone une opération d’échange de jetons telle que pour l’authentification unique.

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

Paramètres

context: TurnContext

Contexte pour le tour de conversation actuel avec l’utilisateur.

connectionName: string

Nom de la connexion d’authentification à utiliser.

userId: string

ID d’utilisateur qui sera associé au jeton.

tokenExchangeRequest: TokenExchangeRequest

Détails de la demande d’échange, un jeton à échanger ou un URI à échanger.

appCredentials: CoreAppCredentials

Optionnel. 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>

Carte 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 façon 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

Optionnel. ID de l’activité pour obtenir les membres de. 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.

Ceci est différent de getConversationMembers dans le fait 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.

Ceci est différent de getActivityMembers dans le fait 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 façon asynchrone une page des conversations dans lesquelles 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 à un objet TurnContext à partir d’une conversation sur le canal.

continuationToken: string

Optionnel. 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 des 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 dans 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 et les informations d’identification du service du bot sont requises.

Les lots de canaux entraînent des pages. Si la propriété continuationToken du résultat n’est pas vide, il existe d’autres pages à obtenir. Utilisez le jeton retourné pour obtenir la page suivante des résultats. Si le paramètre contextOrServiceUrl 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 façon asynchrone un lien de connexion à partir du serveur de jetons qui peut être envoyé dans le cadre d’un 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 redirige.

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 redirige.

appCredentials: CoreAppCredentials

Optionnel. CoreAppCredentials pour OAuth.

Retours

Promise<SignInUrlResponse>

Objet BotSignInGetSignInResourceResponse.

getTokenStatus(TurnContext, string, string)

Récupère de façon 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

Optionnel. S’il est présent, 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

Optionnel. Liste séparée par des virgules des connexions à inclure. Si elle est présente, le paramètre includeFilter limite les jetons retournés par cette méthode.

Retours

Promise<TokenStatus[]>

Les 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

Optionnel. 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 diffusion en continu.

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

Paramètres

req: Request

Une requête HTTP entrante

socket: INodeSocket

Le INodeSocket correspondant

head: INodeBuffer

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

Traitez 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

Une requête HTTP entrante

res: Response

de 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 façon 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 requête 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 des 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 du appId du bot et de l'appPassword. 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 via le pipeline d’intergiciel de l’adaptateur.
Envoie le contexte de tour à la fonction logic.
- Le bot peut effectuer un routage ou un traitement supplémentaires pour l’instant. Le renvoi d’une promesse (ou la fourniture d’un gestionnaire de async) entraîne l’exécution de l’adaptateur pour que les opérations asynchrones se terminent.
- Une fois la fonction logic terminée, la chaîne de promesse configurée par l’intergiciel est résolue.

Pourboire

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 probable est qu’une fonction asynchrone a été utilisée sans utiliser le mot clé await. Assurez-vous que toutes les fonctions asynchrones utilisent await !

Le middleware peut court-circuit un tour. Lorsque cela se produit, l’intergiciel ultérieur et la fonction logic n’est pas appelée ; toutefois, tous les intergiciels avant ce point s’exécutent toujours jusqu’à la fin. Pour plus d’informations sur le pipeline d’intergiciels, consultez la comment les bots fonctionnent et des articles sur les intergiciels. Utilisez la de l’adaptateur utiliser méthode 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 façon 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 des 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 via le pipeline d’intergiciel de l’adaptateur.
Envoie le contexte de tour à la fonction logic.
- Le bot peut effectuer un routage ou un traitement supplémentaires pour l’instant. Le renvoi d’une promesse (ou la fourniture d’un gestionnaire de async) entraîne l’exécution de l’adaptateur pour que les opérations asynchrones se terminent.
- Une fois la fonction logic terminée, la chaîne de promesse configurée par l’intergiciel est résolue.

processRequest(IReceiveRequest)

Vérifie la validité de la requête et tente de la mapper le point de terminaison virtuel approprié, puis génère et retourne une réponse si nécessaire.

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

Paramètres

request: IReceiveRequest

ReceiveRequest à partir du canal connecté.

Retours

Promise<StreamingResponse>

Réponse créée par BotAdapter à envoyer au client à l’origine de la requête.

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 le sendActivity du contexte de tour ou méthode sendActivities à partir de votre code 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 seront envoyées l’une après l’autre dans l’ordre dans lequel elles sont reçues. Un objet réponse est retourné pour chaque activité envoyée. Pour message activités qui contiennent 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 façon asynchrone une activité précédente par une version mise à jour. Cette interface prend en charge l’infrastructure et n’est pas destinée à être appelée directement pour votre code. Utilisez TurnContext.updateActivity pour mettre à jour une activité à partir de votre code 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 le 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ère 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 du canal entrant et sortant

onListen: () => void

Rappel facultatif qui se déclenche une fois lorsque le serveur écoute 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 diffusion en continu.

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 diffusion en continu entrantes pendant toute 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, éventuellement 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>

Une ConversationReference partielle à la conversation pour continuer.

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

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

Retours

Promise<void>

une promesse représentant l’opération asynchrone

héritée de BotAdapter.continueConversationAsync

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

Reprend de façon asynchrone une conversation avec un utilisateur, éventuellement 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>

Une ConversationReference partielle à la conversation pour continuer.

audience: string

Valeur indiquant le destinataire du message proactif.

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

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

Retours

Promise<void>

une promesse représentant l’opération asynchrone

héritée de BotAdapter.continueConversationAsync

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

Reprend de façon asynchrone une conversation avec un utilisateur, éventuellement 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 un seul locataire, les adaptateurs (console, test, etc.), mais il est essentiel pour BotFrameworkAdapter, qui prend en charge plusieurs locataires.

reference: Partial<ConversationReference>

Une ConversationReference partielle à la conversation pour continuer.

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

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

Retours

Promise<void>

une promesse représentant l’opération asynchrone

héritée 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

Public 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 de message direct (non-groupe).

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

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

héritée de BotAdapter.createConversationAsync

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

Ajoute un intergiciel 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[]

Les 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ée de BotAdapter.use

Partager 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