Webhook

Webhook is a provision in cidaas that allows executing business specific requirements when specific events occur during the registration or login.

cidaas provides a Webhook URL (location / client's Webhook receiver) and key to be configured by the Administrator user.

Find the below pre-defined events list cidaas provides:

Webhook modification

Create Webhook

1. Click “Create Webhook” button.
2. Select the Webhook events from the drop down.

3. Enter the Webhook URL.
4. Administrator can secured your url by using the following any one methods:

• API-Key Enter the Webhook API-Key, as in the below screen

• TOTP Key Enter the Webhook TOTP-Key, as in the below screen

• cidaas Oauth2 Enter the Webhook cidaas Oauth2, as in the below screen

5. Click “Save” button, a message window popup “Webhook Saved Successfully” 6. Click “OK” button, the webbook grid table get displayed as in the below screen

Edit Webhook Template

1. From the created Webhooks, click on the icon Edit Template
2. Edit the appropriate changes
3. Click “Save” button.

Delete Webhook Template

1. From the created Webhooks, click on the delete icon.
2. A confirmation window popup to delete the Webhooks.
3. Click “YES” button to confirm the delete or click “NO” button to cancel the delete.

Client Webhook Receiver Implementation

The Client Webhook receiver needs to handle the following:

1. Receive the event and acknowledge the cidaas Webhook event.
2. Get Access Token.
3. Get User Info.
4. Handle the Event Types.
5. Receive the Event and acknowledge the cidaas Webhook: That is, parse the payload from the cidaas Webhook event and respond back with 200 ok, if not this will appear in the failed Webhooks report.
6. Get Access Token: Use your Non-Interactive Client application's client_id and client_secret to obtain the access_token from cidaas.
7. Let us see how by using sample node js application: This is my sample node js application's folder structure

TokenResolver.js

var request = require('request');

var getAccessToken = (config, callback) => {

  var options = {
    uri: config.token_url,
    form: {
      grant_type: 'client_credentials',
      client_id: config.client_id,
      client_secret: config.client_secret
    }
  };

  request.post(options, (error, response, body) => {
    if (error) {

      callback({
        error: error
      });
      return;
    }
    if (body && typeof body == "string") {
      try {
        body = JSON.parse(body);
        callback({
          error: null,
          data: body
        });
        return;
      } catch (error) {
        console.log("error while parsing");
      }
    }
    callback({
      error: "error while getting token info"
    });
  });

};

module.exports = {
  getAccessToken: getAccessToken
};

1. Get User Info

UserinfoResolver.js

var request = require('request');

var getUserInfo = (config, userId, access_token, callback) => {

  var options = {
    uri: config.userinfo_url + "/" + userId,
    headers: {
      "access_token": access_token,
      "content-type": 'application/json'
    }
  };

  request.get(options, (error, response, body) => {
    if (error) {

      callback({
        error: error
      });
      return;
    }
    if (body && typeof body == "string") {
      try {
        body = JSON.parse(body);
        callback({
          error: null,
          data: body
        });
        return;
      } catch (error) {
        console.log("error while parsing");
      }
    }
    callback({
      error: "error while getting user info"
    });
  });

};

module.exports = {
  getUserInfo: getUserInfo
};

2. Handle the Event Types

WebhookHandlerController.js

var HttpStatus = require('http-status-codes');
var request = require('request');
var async = require('async');
var tokenResolver = require.main.require("./Model/TokenResolver.js");
var userInfoResolver = require.main.require("./Model/UserInfoResolver.js");

var cidaasConfig = require.main.require("./Resources/conf/cidaas-service.json");

module.exports = function(app) {

  /**
   * Sample Body JSON
   {

      "eventtype":"ACCOUNT_CREATED_WITH_CIDAAS_IDENTITY",

      "userId":"09874dac-f3bc-422a-b169-786f2a079157",

      "createTime":1472451637774,

      "providerName":"Facebook",

      "client_id":"5a5a0a92511f46a58e505d223e0eddb4"

  }
   */
  app.post("/receiver", function(req, res) {
    var requestData = req.body;
    async.parallel({
      handlewebhook: function(callback) {

        try {
          tokenResolver.getAccessToken(cidaasConfig, (tokenResponse) => {
            if (tokenResponse.error) {
              callback(null, {
                error: tokenResponse.error,
                status: HttpStatus.INTERNAL_SERVER_ERROR
              });
              return;
            }
            userInfoResolver.getUserInfo(cidaasConfig, requestData.userId, tokenResponse.data.access_token, (userInfo) => {
              if (userInfo.error) {
                callback(null, {
                  error: userInfo.error,
                  status: HttpStatus.INTERNAL_SERVER_ERROR
                });
                return;
              }

              switch (requestData.eventtype) {
                case "ACCOUNT_CREATED_WITH_CIDAAS_IDENTITY":
                case "ACCOUNT_CREATED_WITH_SOCIAL_IDENTITY":
                  console.log("New user created in cidaas ");
                  console.log(userInfo);

                  callback(null, {
                    data: "New user created in cidaas ",
                    status: HttpStatus.OK
                  });
                  break;

                case "LOGIN_WITH_CIDAAS":
                case "LOGIN_WITH_SOCIAL":
                  console.log("User logged in Cidaas ");
                  console.log(userInfo);
                  callback(null, {
                    data: "done",
                    status: HttpStatus.OK
                  });
                  break;

                default:
                  console.log("Un handled events ");
                  callback(null, {
                    data: "done",
                    status: HttpStatus.OK
                  });
                  break;
              }
            });
          });

        } catch (error) {
          callback(null, {
            error: userInfo.error,
            status: HttpStatus.INTERNAL_SERVER_ERROR
          });
        }
      }
    }, function(error, results) {
      if (results.handlewebhook.status == HttpStatus.OK) {
        return res.status(results.handlewebhook.status).send(results.handlewebhook.data);
      } else {
        return res.status(results.handlewebhook.status).end();
      }
    });
  });

};

Note In the receiver side, you must use @JsonIgnoreProperties(ignoreUnknown=true) if you are using the strict JSON parser validation.