Sessions

Les sessions vous permettent de créer et de conserver un contexte au sein de votre instance de manière transparente. Votre instance peut avoir plusieurs sessions, une relation d'une (instance) à plusieurs (sessions). Les sessions sont créées lorsque vous souhaitez utiliser une instance Vonage Cloud Runtime. fournisseur du SDK. Les sessions peuvent ensuite être restaurées lors d'appels ultérieurs à votre instance pour accéder au contexte précédent.

Création d'une session

Les sessions peuvent être créées en appelant la fonction createSession fonction :

const session = vcr.createSession();

Par défaut, les sessions ont un TTL de 7 jours, mais cela peut être modifié en fournissant une valeur de TTL personnalisé dans le createSession fonction.

La nouvelle session peut être utilisée pour accéder aux fournisseurs et à l'état :

const session = vcr.createSession();
const voice = new Voice(session);
const state = new State(session);

L'appel de fonctions sur le voice ou state sera désormais associé à cette session. Pour ce faire, Vonage Cloud Runtime place un en-tête sur les demandes avec l'identifiant de la session.

Création d'une session avec un TTL personnalisé

Pour créer une session avec un TTL personnalisé, vous pouvez fournir un TTL en secondes à la fonction createSession fonction :

const session = vcr.createSession(3600);

Cette opération crée une session d'une durée d'une heure.

La session mondiale

La session globale est utile pour créer des fournisseurs lorsque vous ne préservez pas le contexte. Vous pouvez obtenir la session globale à l'aide de la fonction getGlobalSession fonction :

const session = vcr.getGlobalSession();

Restauration de la session

Vous pouvez enregistrer une session en vue d'une utilisation ultérieure, puis restaurer la session à partir d'un identifiant de session :

const session = vcr.getSessionById('sessionID');

Lorsque votre application reçoit des demandes ultérieures, vous pouvez restaurer une session existante à l'aide de la fonction getSessionFromRequest fonction :

app.post('/onMessage', async (req, res, next) => {
    const session = vcr.getSessionFromRequest(req);
    ...
});

getSessionFromRequest recherchera un en-tête dans la requête :

'x-neru-sessionid': '44092039-fa65-41a6-a9ce-97a7d1274b96',

Puis en utilisant l'identifiant de session dans l'en-tête de la requête, getSessionFromRequest en interne, on appellera getSessionById. Cela vous permet de raisonner sur votre code par rapport à une session et aux événements d'une session.

Cela simplifie les opérations d'état puisque vous pouvez être certain que l'objet d'état de la session ne connaît que cette session.

Exemple de restauration de session

En guise de démonstration, voici un exemple d'application Vonage Cloud Runtime qui transporte le contexte entre un appel téléphonique entrant et un message texte provenant du même utilisateur :

app.post('/onCall', async (req, res, next) => {
    const session = vcr.createSession();
    const voice = new Voice(session);
    const messages = new Messages(session);

    await voice.onVapiEvent({ vapiUUID: req.body.uuid, callback: "onEvent" }).execute();
    await messages.onMessage(
        'onMessage',
        {type: 'sms', number: req.body.from },
        vonageNumber
    ).execute();

    res.json([
        {
            action: 'talk',
            text: 'Say some words, then text this number for a transcript',
        },
        {
          "action": "input",
          "type": ["speech"]
        }
    ]);
});

Les onCall est appelée en cas d'appel entrant dans l'application. Une nouvelle session est créée, qui est utilisée pour mettre en place un récepteur pour les messages SMS entrants du numéro appelant ainsi que pour les événements vocaux de l'appel.

La plateforme Vonage Cloud Runtime reçoit les webhooks RTC, Voix et Messages entrants dans votre application Vonage, comme configuré par . vcr app configure. Si vous disposez d'un récepteur pour ces webhooks, ils seront envoyés à votre application si le webhook entrant répond aux filtres du récepteur, par exemple le numéro d'origine.

Étant donné que les écouteurs sont configurés avec une session, toutes les demandes qui satisfont aux filtres de l'écouteur seront envoyées à votre application sur la route spécifiée avec l'attribut x-neru-sessionid set.

app.post('/onEvent', async (req, res, next) => {
    if (req.body.speech != null) {
        const session = vcr.getSessionFromRequest(req);
        const state = new State(session);
        await state.set('text', req.body.speech.results[0].text);
    } else {
        console.log(req.body)
    }
    res.sendStatus(200);
});

Dans le cadre de la onEvent une session est restaurée à l'aide de l'option getSessionFromRequest. L'état de cette session est utilisé pour stocker les résultats de la synthèse vocale de l'appel téléphonique. Remarquez qu'il n'a pas été nécessaire d'utiliser un identifiant quelconque pour l'état, puisque celui-ci est local à cette session, qui est la même que celle créée lors de l'appel de l'utilisateur.

app.post('/onMessage', async (req, res, next) => {
    const session = vcr.getSessionFromRequest(req);
    const messages = new Messages(session);
    const state = new State(session);
    const text = await state.get('text');
   
    await messages.send({
        message_type: "text",
        to: req.body.from,
        from: vonageNumber.number,
        channel: vonageNumber.type,
        text: text
    }).execute();

    res.sendStatus(200);
});

Enfin, une fois que l'utilisateur a envoyé un texte entrant pour demander la transcription de son appel en onMessageLa session d'origine est rétablie, avec l'état qu'elle contient.