How to use dialogflow Fulfillment Inline Editor to save users names and moods on a realtime database?

Question

I built action on google using dialogflow for experience sampling purpose. It's idea is: it asks specific users about their mood 3 times per day. It sends these users then every week a weekly overview about their mood after it has been analysed by researchers.

So I need to save each user info with his mood entries on a database so they can be accessed later by researchers, analysed and sent back to users.

I'm using dialogflow fulfilment with index.js to connect to Firebase database to save the entries. This agent should be integrated as action on google

On the database I get users names and moods but they are not related to each other so I cannot know which user entered which mood and, also I cannot do the userID check.

I would really appreciate if anybody could help me with the functions since I am totally unfamiliar with node.js or databases but I have to do it that way.

here is my code.

// See https://github.com/dialogflow/dialogflow-fulfillment-nodejs
// for Dialogflow fulfillment library docs, samples, and to report issues
'use strict';
 
const functions = require('firebase-functions');
const {WebhookClient} = require('dialogflow-fulfillment');
const {Card, Suggestion} = require('dialogflow-fulfillment');
 
 
 //initialise DB connection
 const admin = require('firebase-admin');
 admin.initializeApp();
 
 
process.env.DEBUG = 'dialogflow:debug'; // enables lib debugging statements
 
exports.dialogflowFirebaseFulfillment = functions.https.onRequest((request, response) => {
  const agent = new WebhookClient({ request, response });
  console.log('Dialogflow Request headers: ' + JSON.stringify(request.headers));
  console.log('Dialogflow Request body: ' + JSON.stringify(request.body));
 
   function saveName(agent) {
       const nameParam = agent.parameters.name;
       const context = agent.getContext('awaiting_name_confirm');
       const name = nameParam || context.parameters.name;
       agent.add('Hi ' + name + ' Are you ready to answer my question?' || 'Hi' + name + 'Have you got a moment for me? '  );
       //agent.add('Hi' + name + 'Have you got a minute for me? ');
       
       return admin.database().ref('/names').push({name: name}).then((snapshot)=>
       {
       
           console.log('database write sucessful: ' + snapshot.ref.toString());
       });
   }
 
  function saveMood(agent) {
       const moodParam = agent.parameters.mood;
       const mood = moodParam; 
       
       agent.add('That is good! keep it up. Thanks for sharing with me! Bye ');
       //agent.add('Hi' + name + 'Have you got a minute for me? ');
       
       return admin.database().ref('/moods').push({mood: mood}).then((snapshot)=>
       {
       
           console.log('database write sucessful: ' + snapshot.ref.toString());
       });
  }
   
  // Run the proper function handler based on the matched Dialogflow intent name
  let intentMap = new Map();
  intentMap.set('Get Name', saveName);
  intentMap.set('Confirm Name Yes', saveName);
  // intentMap.set('Confirm Name Yes', getName);
  intentMap.set('attentiveness', saveMood);

  agent.handleRequest(intentMap);
});

Answer 1

You have a few issues in your code and approach that you'll need to address:

• You need to design your database so that you can associate the user's mood with their account. (And possibly other user information, such as their name or email address, while you're at it.)
• You need a unique identity for the person.
  • A person's name isn't a unique identity. Two people may have the same name, or the system may hear the name differently each time, so you need to have a way to know who you're talking to.
  • You also need to know their email address and possibly other information, so you can send them their report at the end of the week.
• You need to make sure you have their identity between calls to your Action during the same conversation.

Fortunately, you do one thing that is typically missed - you make your calls to the database using Promises. So that part works.

Unique Identity

Your example code asks the user for their name, which it sounds like you intend to use as their identity. Unfortunately, this is a bad idea for a few reasons:

• The name isn't an identity. What happens if two people with the same name access your Action?

• Names are easily discoverable, so other people could use it and report misleading information. This may not be too serious in your case, but it can still have trustworthiness implications.

• Names can be Personally Identifiable Information (PII), so may be covered by additional privacy laws.

• Users might want to terminate their account, and can't do this without "changing" their name.

Additionally, you may need other identity information later, such as their email address, and asking for that every time may become troublesome.

You have a few ways to deal with this:

• If you're developing for the Google Assistant, you can also use Google Sign In for Assistant which will tell you the user's Google identifier, which you can use as a unique ID. You also get their email address and name as part of their profile.

• You can ask for this information (name, email, etc) and save it against a user ID that you generate or a user name the user provides. This ID becomes the identifier. If you're developing for the Google Assistant, you can save this ID in the user's private storage - only you and the user have access to it or can delete it. If not, you may need to use the database to look up the ID. More on this later.

• You may wish to use variants on this later point, depending what information you're getting and how you want the user to identify themselves every time. But the important part is that they need to identify themselves with something unique and that you can easily capture.

Use identity in the same session

If you're using Google Sign In, you don't have to worry about this. You'll get the same ID each session and for each call during a session.

If you're using the user's private storage with the Google Assistant, you'll have this as part of the userStore object.

But if you're not, you need to make sure that you get the user's ID in an early intent, and saving this as part of a Context so it is preserved in between calls to your webhook. In subsequent handlers, you can get the ID out of the context and then use it to access other information.

You don't need to store it in the database at this point. All you have is an identifier - this becomes the key that you will use for other information. You just need to remember it for later parts of the conversation.

So in your saveName() function, it might look something like

   function saveName(agent) {
       const nameParam = agent.parameters.name;
       agent.add('Hi ' + nameParam + ' Are you ready to answer my question?');
       agent.setContext({
         name: 'user',
         lifespan: 99,
         parameters: {
           id: nameParam
         }
       };
   }

As an aside - your handler seems to try to determine if this is the user saying their name, or confirming their name. This is probably better handled as separate intents and separate handlers. Trying to combine them will confuse things.

Structuring and Accessing your Database

We have an ID. We have the user reporting the data. How do we associate the two?

There are a lot of ways to structure the data, and Firebase goes into some detail depending on how you intend to use it, access it, and make it available to the users or others.

In this case, it seems pretty straightforward that you want to store records about the user. Each record can use their ID as a key, and then contain some information about the user, including their mood.

One nice thing about the Firebase database is that you can (mostly) treat it like a Javascript object. If we think about it this way, it might look something like

{
  "user": {
    "id1":{...},
    "id2":{...},
    "id3":{
       "moods": [
         {"mood":"good"},
         {"mood":"tired"}
       ]
    },
    "id4":{...}
  }
}

And so forth. With Firebase, we would reference the moods of user "id3" with a path such as user/id3/moods. If we have the user id in a variable name, we might use the following code to get that reference

var ref = admin.database().ref('user').ref(name).ref('moods');

and then use code such as this to push an object with the mood onto the array (and return the Promise that we need to do):

var obj = {
  mood: mood
};
return ref.push( obj ).then( snapshot => {
  // Do stuff, including acknowledge to the user you saved it.
});

Keep in mind that you may want to also use this to store more information about each user (such as their name or email) on the user level, or more about the moods (such as a timestamp) in the mood object.