Come integrare Dialogflow con BigQuery

1. Introduzione

In questo articolo scoprirai in che modo Dialogflow si connette a BigQuery e archivia le informazioni raccolte durante l'esperienza di conversazione. Utilizzeremo lo stesso agente che abbiamo creato nei lab precedenti." Programma degli appuntamenti". Nel progetto Google Cloud dell'agente creeremo un set di dati e una tabella in BigQuery. Poi modificheremo il completamento originale con il set di dati e gli ID tabella BigQuery. Infine, eseguiremo un test per verificare se le interazioni vengono registrate in BigQuery.

Ecco il diagramma di sequenza degli eventi dall'utente al fulfillment e a BigQuery.

Obiettivi didattici

• Come creare un set di dati e una tabella in BigQuery
• Come configurare i dettagli della connessione BigQuery nel completamento Dialogflow.
• Come testare il fulfillment

Prerequisiti

• Concetti di base e costrutti di Dialogflow. Per video tutorial introduttivi su Dialogflow che illustrano la progettazione conversazionale di base, guarda i seguenti video:

• Creare un chatbot per il Programma di pianificazione degli appuntamenti utilizzando Dialogflow.

• Informazioni sulle entità in Dialogflow.

• Fulfillment: integrare Dialogflow con Google Calendar.

2. crea un set di dati e una tabella in BigQuery

1. Vai alla console Google Cloud.
2. Nella console Cloud, vai all'icona del menu senso > > Big data > BigQuery
3. In Risorse nel riquadro a sinistra, fai clic sull'ID progetto. Una volta selezionato, vedrai CREA SET DI DATI sulla destra
4. Fai clic su CREA SET DI DATI e assegnagli un nome.

5. Dopo aver creato il set di dati, fai clic sul set di dati nel riquadro a sinistra. Sulla destra vedrai CREA TABELLA.
6. Fai clic su CREA TABELLA, fornisci il nome della tabella e fai clic su Crea tabella nella parte inferiore dello schermo.

7. Una volta creata la tabella, fai clic sulla tabella nel riquadro di sinistra. Il pulsante "Modifica schema" si trova sul lato destro.
8. Fai clic sul pulsante Edit Schema (Modifica schema) e poi sul pulsante Add Field (Aggiungi campo). Aggiungi "data" e ripeti la stessa operazione per "tempo" e "type".
9. Prendi nota di "DatasetID" e "DatasetID"

3. Aggiungere i dettagli della connessione BigQuery a Dialogflow Fulfillment

1. Apri l'agente Dialogflow e abilita l'editor incorporato di Fulfillment. Se hai bisogno di aiuto, fai riferimento al lab precedente .

Se hai bisogno di aiuto per abilitare il fulfillment, consulta il codelab precedente Informazioni sul fulfillment mediante l'integrazione di Dialogflow con Google Calendar.

2. Assicurati che "package.json" nell'editor incorporato del fulfillment Dialogflow contenga una dipendenza BigQuery. "@google-cloud/bigquery": "0.12.0". Assicurati di utilizzare la versione più recente di BigQuery quando segui questo articolo.
3. In index.js, crea "addToBigQuery" per aggiungere la data, l'ora e il tipo di appuntamento alla tabella BigQuery.
4. Aggiungi projectID, datasetID e tableID nella sezione TODO del file index.js per collegare correttamente la tabella BigQuery e il set di dati al tuo fulfillment.

package.json

{
  "name": "dialogflowFirebaseFulfillment",
  "description": "Dialogflow fulfillment for the bike shop sample",
  "version": "0.0.1",
  "private": true,
  "license": "Apache Version 2.0",
  "author": "Google Inc.",
  "engines": {
    "node": "6"
  },
  "scripts": {
    "lint": "semistandard --fix \"**/*.js\"",
    "start": "firebase deploy --only functions",
    "deploy": "firebase deploy --only functions"
  },
  "dependencies": {
    "firebase-functions": "2.0.2",
    "firebase-admin": "^5.13.1",
    "actions-on-google": "2.2.0", 
    "googleapis": "^27.0.0",
    "dialogflow-fulfillment": "0.5.0",
    "@google-cloud/bigquery": "^0.12.0"
  }
}

Index.js

'use strict';

const functions = require('firebase-functions');
const {google} = require('googleapis');
const {WebhookClient} = require('dialogflow-fulfillment');
const BIGQUERY = require('@google-cloud/bigquery');


// Enter your calendar ID below and service account JSON below
const calendarId = "[e-mail]";
const serviceAccount = {}; // Starts with {"type": "service_account",...

// Set up Google Calendar Service account credentials
const serviceAccountAuth = new google.auth.JWT({
  email: serviceAccount.client_email,
  key: serviceAccount.private_key,
  scopes: 'https://www.googleapis.com/auth/calendar'
});

const calendar = google.calendar('v3');
process.env.DEBUG = 'dialogflow:*'; // enables lib debugging statements

const timeZone = 'America/Los_Angeles';
const timeZoneOffset = '-07:00';

exports.dialogflowFirebaseFulfillment = functions.https.onRequest((request, response) => {
  const agent = new WebhookClient({ request, response });
  console.log("Parameters", agent.parameters);
  const appointment_type = agent.parameters.AppointmentType;

// Function to create appointment in calendar  
function makeAppointment (agent) {
    // Calculate appointment start and end datetimes (end = +1hr from start)
    const dateTimeStart = new Date(Date.parse(agent.parameters.date.split('T')[0] + 'T' + agent.parameters.time.split('T')[1].split('-')[0] + timeZoneOffset));
    const dateTimeEnd = new Date(new Date(dateTimeStart).setHours(dateTimeStart.getHours() + 1));
    const appointmentTimeString = dateTimeStart.toLocaleString(
      'en-US',
      { month: 'long', day: 'numeric', hour: 'numeric', timeZone: timeZone }
    );
  
// Check the availability of the time, and make an appointment if there is time on the calendar
    return createCalendarEvent(dateTimeStart, dateTimeEnd, appointment_type).then(() => {
      agent.add(`Ok, let me see if we can fit you in. ${appointmentTimeString} is fine!.`);

// Insert data into a table
      addToBigQuery(agent, appointment_type);
    }).catch(() => {
      agent.add(`I'm sorry, there are no slots available for ${appointmentTimeString}.`);
    });
  }

  let intentMap = new Map();
  intentMap.set('Schedule Appointment', makeAppointment);
  agent.handleRequest(intentMap);
});

//Add data to BigQuery
function addToBigQuery(agent, appointment_type) {
    const date_bq = agent.parameters.date.split('T')[0];
    const time_bq = agent.parameters.time.split('T')[1].split('-')[0];
    /**
    * TODO(developer): Uncomment the following lines before running the sample.
    */
    //const projectId = '<INSERT your own project ID here>'; 
    //const datasetId = "<INSERT your own dataset name here>";
    //const tableId = "<INSERT your own table name here>";
    const bigquery = new BIGQUERY({
      projectId: projectId
    });
   const rows = [{date: date_bq, time: time_bq, type: appointment_type}];
  
   bigquery
  .dataset(datasetId)
  .table(tableId)
  .insert(rows)
  .then(() => {
    console.log(`Inserted ${rows.length} rows`);
  })
  .catch(err => {
    if (err && err.name === 'PartialFailureError') {
      if (err.errors && err.errors.length > 0) {
        console.log('Insert errors:');
        err.errors.forEach(err => console.error(err));
      }
    } else {
      console.error('ERROR:', err);
    }
  });
  agent.add(`Added ${date_bq} and ${time_bq} into the table`);
}

// Function to create appointment in google calendar  
function createCalendarEvent (dateTimeStart, dateTimeEnd, appointment_type) {
  return new Promise((resolve, reject) => {
    calendar.events.list({
      auth: serviceAccountAuth, // List events for time period
      calendarId: calendarId,
      timeMin: dateTimeStart.toISOString(),
      timeMax: dateTimeEnd.toISOString()
    }, (err, calendarResponse) => {
      // Check if there is a event already on the Calendar
      if (err || calendarResponse.data.items.length > 0) {
        reject(err || new Error('Requested time conflicts with another appointment'));
      } else {
        // Create event for the requested time period
        calendar.events.insert({ auth: serviceAccountAuth,
          calendarId: calendarId,
          resource: {summary: appointment_type +' Appointment', description: appointment_type,
            start: {dateTime: dateTimeStart},
            end: {dateTime: dateTimeEnd}}
        }, (err, event) => {
          err ? reject(err) : resolve(event);
        }
        );
      }
    });
  });
}

Comprendi la sequenza di eventi dal codice

1. La mappa dell'intent chiama la funzione "makeAppointment" per programmare un appuntamento su Google Calendar.
2. All'interno della stessa funzione viene effettuata una chiamata a "addToBigQuery" per inviare i dati da accedere a BigQuery.

4. Testa il chatbot e la tabella BigQuery.

Proviamo il nostro chatbot, potete provarlo nel simulatore oppure utilizzare l'integrazione web o Google Home che abbiamo imparato negli articoli precedenti.

• Utente: "Fissa un appuntamento per l'immatricolazione del veicolo alle 14:00 di domani"
• Risposta del chatbot: "Vediamo se possiamo soddisfare la tua richiesta. Il 6 agosto alle 14:00 va bene!".

• Controlla la tabella BigQuery dopo la risposta. Utilizza la query "SELECT * FROM projectID.datasetID.tableID"

5. Esegui la pulizia

Se hai intenzione di eseguire gli altri lab di questa serie, non eseguire ora la pulizia, ma dopo aver completato tutti i lab della serie.

Eliminare l'agente Dialogflow

• Fai clic sull'icona a forma di ingranaggio accanto all'agente esistente.

• Nella scheda General (Generale), scorri fino in fondo e fai clic su Delete this Agent (Elimina questo agente).
• Digita DELETE nella finestra visualizzata e fai clic su Elimina.

6. Complimenti!

Hai creato un chatbot e lo hai integrato con BigQuery per ottenere insight. Ora sei uno sviluppatore di chatbot.

Dai un'occhiata a queste altre risorse:

Passaggi successivi:

Dai un'occhiata ai codelab di questa serie per saperne di più sulla creazione di un chatbot con Dialogflow e sulle integrazioni.

• Creare un front-end Dialogflow personalizzato con Django
• Integrare l'API Google Vision con Dialogflow

• Controlla gli esempi di codice nella pagina GitHub Dialogflow.