Building a RingCentral bot from scratch

// In this tutorial, we store the access token in a file so that we can reuse it
// every time we terminate and restart the bot.

// If the access token is lost, you will need to remove and reinstall the bot in order
// to obtain a new access token.

// In a real production implementation, the acess token should be saved in a more secure
// place and persistent so that it can be reliably re-used if the bot is restarted.
app.post('/oauth', async function (req, res) {
  console.log("Private bot being installed");
  if (req.body.access_token) {
    res.status(200).send('')
    // Bot access token is almost permanent. Thus, there is no need for a refresh token!
    // For calling RC Team Messaging API to post messages using the RingCentral JS SDK, we need
    // to create a token object and set it to the SDK's platform instance.

    // First, we get an empty token object from the platform instance, then we assign the
    // access token, the token type and other fake values to satify the SDK's tokens syntax.
    var tokenObj = platform.auth().data();
    tokenObj.access_token = req.body.access_token;
    tokenObj.token_type = "bearer"
    tokenObj.expires_in = 100000000000;
    tokenObj.refresh_token = 'xxx';
    tokenObj.refresh_token_expires_in = 10000000000;

    // Finally, we set the token object back to the platform instance and also save it to a file
    // for reuse.
    await platform.auth().setData(tokenObj);
    console.log( "Save tokens to a local file for reuse" )
    fs.writeFileSync( TOKEN_TEMP_FILE, JSON.stringify( tokenObj ) )

    console.log("Bot installation done")
    // The bot must subscribe for Team Messaging events notification so that it can receive messages
    // and other important events notification from bot users and from RingCentral server.
    subscribeToEvents()
  }else{
    res.status(401).end()
  }
});

// Callback method received after subscribing to webhook. This method handles webhook
// notifications and will be invoked when a user sends a message to your bot, and when
// the bot is added to/removed from a group or a team etc.
app.post('/webhook-callback', async function (req, res) {
  var validationToken = req.get('Validation-Token');

// Handle authorization for public bots
//
// When a public bot is installed, RingCentral sends an authorization code to the bot via
// an HTTP GET request through the specified redirect url. When the bot receives
// the authorization code, it must uses the code to exchange for an access token.

// In this tutorial, we store the access tokens in a file so that we can reuse it
// every time we terminate and restart the bot.

// If the access token of a user's account is lost, the customer will need to reinstall
// the bot in order for the bot to obtain a new access token for that account.

// In a real production implementation, the acess token should be saved in a more secure
// place and persistent so that it can be reliably re-used if the bot is restarted.
app.get('/oauth', async function (req, res) {
    console.log("Public bot being installed");
    if (!req.query.code){
        res.status(500).send({"Error": "Authorization code is missing."})
        console.log("RingCentral did not send an authorizaton code.");
    } else {
        var creatorId = req.query.creator_extension_id;
        try {
          var params = {
              code : req.query.code,
              redirectUri : process.env.RC_REDIRECT_URL
          }
          var platform = rcsdk.platform()
          var resp = await platform.login(params)
          // Get bot access token. The tokens is per user's account
          var tokens = await resp.json()

          // Get user's account id. The account id will be used to identify a public user so that we
          // can use the correct access token to post messages to users under that account.
          var resp1 = await platform.get('/restapi/v1.0/account/~/extension/~')
          var jsonObj = await resp1.json()

          // Bot access token is almost permanent. Thus, there is no refresh token associated with the access token!
          // However, before saving the access token for reuse, we assign fake refresh token values to satify
          // the SDK's tokens syntax.
            tokens['refresh_token'] = 'xxx';
            tokens['refresh_token_expires_in'] = 10000000000;

          // Make an account token object for reuse
          var accountTokenObj = {
            ownerId: tokens.owner_id, // Bot extension id
            accountId: jsonObj.account.id, // User account id
            tokens: tokens,
            subscriptionId: ''
          }
          // Add this new token object to our accountTokens array
          accountTokens.push(accountTokenObj)
          res.status(200).send("")
          console.log("Subscribe to Webhooks notification")
          // The bot must subscribe for Team Messaging notifications so that it can receive messages
          // from RingCentral server and from bot users.
          subscribeToEvents(platform, accountTokenObj);
        }catch(e){
          console.error(e.message)
            res.status(500).send({"Error": "Installing bot and subscribing to events failed."})
        }
    }
});

});

// Callback method received after subscribing to webhook. This method handles webhook

      "/restapi/v1.0/glip/groups", // Team Messaging (a.k.a Glip) events.
      "/restapi/v1.0/account/~/extension/~", // Subscribe for this event to detect when a bot is uninstalled
      "/restapi/v1.0/subscription/~?threshold=60&interval=15" // For subscription renewal
    ],
    deliveryMode: {
      transportType: "WebHook",
      address: process.env.WEBHOOK_DELIVERY_ADDRESS
    },
    expiresIn: 604799
  };
  try {
    var resp = await platform.post('/restapi/v1.0/subscription', requestData)
    var jsonObj = await resp.json()
    console.log('Team Messaging events notifications subscribed successfully.');
    // Save the subscription id to a file so that we can check its status every time the
    // bot is restarted.
    fs.writeFileSync( SUBSCRIPTION_ID_TEMP_FILE, jsonObj.id )
    console.log('Your bot is ready for conversations ...');
  }catch (e) {
    console.error('Team Messaging events notifications subscription failed. ', e);
    throw e;
  }
}

async function renewSubscription(id){
  console.log("Auto subscription renewal");
  try{
    var resp = await platform.post(`/restapi/v1.0/subscription/${id}/renew`)
    var jsonObj = await resp.json()

          // The bot must subscribe for Team Messaging notifications so that it can receive messages
          // from RingCentral server and from bot users.
          subscribeToEvents(platform, accountTokenObj);

        "eventFilters": [
            "/restapi/v1.0/glip/posts", // Team Messaging (a.k.a Glip) Events.
            "/restapi/v1.0/glip/groups", // Team Messaging (a.k.a Glip) Events.
            "/restapi/v1.0/account/~/extension/~", // Subscribe for this event to detect when a bot is uninstalled
            "/restapi/v1.0/subscription/~?threshold=60&interval=15" // For subscription renewal
        ],
        "deliveryMode": {
            "transportType": "WebHook",
            "address": process.env.WEBHOOK_DELIVERY_ADDRESS
        },
        "expiresIn": 604799
    };
    try {
      var resp = await p.post('/restapi/v1.0/subscription', requestData)
      var jsonObj = await resp.json()
      console.log('Team Messaging events notifications subscribed successfully.');
      accountTokenObj.subscriptionId = jsonObj.id

      // Save tokens to a file so that we can reuse the access token after we terminate and
      // restart the bot.
      fs.writeFileSync( TOKEN_TEMP_FILE, JSON.stringify( accountTokens ) )
      console.log('Your bot is ready for conversations ...');
    }catch (e) {
      console.error('Team Messaging events notifications subscription failed. ', e);
      throw e;
    }
}

async function renewSubscription(p, id){
    console.log("Auto subscription renewal");
    try{

    console.log('Verifying Webhook token.');
    res.setHeader('Validation-Token', validationToken);
  } else if (req.body.event == "/restapi/v1.0/subscription/~?threshold=60&interval=15") {
    console.log("Renewing subscription ID: " + req.body.subscriptionId);


    } else if (body.text == "ping") {
      send_message( body.groupId, "pong" )
    // Add more bot commands here by training your bot to respond to different keywords
    // } else if (req.body.body.text == "some keyword") {
    //   send_message( body.groupId, "reply message" )
    } else if (body.text == "hello") {
      var card = make_hello_world_card(null)
      send_card( body.groupId, card )


    eventFilters: [


       })
    }catch(e) {
        console.log(e)
    }
}

// Send an adaptive card to a chat
async function send_card( groupId, card ) {
    console.log("Posting a card to group: " + groupId);
    try {

// Callback method received after subscribing to webhook. This method handles webhook
// notifications and will be invoked when a user sends a message to your bot, and when
// the bot is added to/removed from a group or a team etc.
app.post('/webhook-callback', async function (req, res) {


    } else if (req.body.body.eventType == "PostAdded") {
      // get the account's token object
      var account = accountTokens.find(o => o.ownerId == req.body.ownerId)
      if (account){
        var platform = rcsdk.platform()
        await platform.auth().setData(account.tokens)
        var body = req.body.body
        console.log("Received user's message: " + body.text);
        console.log(req.body)
        if (req.body.ownerId == body.creatorId) {
          console.log("Ignoring message posted by bot.");
        } else if (body.text == "ping") {
          send_message( platform, body.groupId, "pong" )


});


// Post a message to a chat
async function send_message( p, groupId, message ) {
    console.log("Posting response to group: " + groupId);
    try {
      await p.post(`/restapi/v1.0/glip/chats/${groupId}/posts`, {
         "text": message
       })
     }catch(e) {
      console.log(e)
    }
}