How to use the twilio.webhook function in twilio

'use strict'

const config = require('config')
const express = require('express')
const twilio = require('twilio')
const content = require('../../static/content')
const replies = require('../commands/util/replies')

// Create a router for the SMS webhooks
let router = new express.Router()

// Configure Twilio request signature validation for production
let validator = twilio.webhook(config.get('twilio.authToken'), {
  validate: config.get('env') === 'production',
  includeHelpers: false,

  // This needs to be the full webhook URL configured on Twilio
  url: `${config.get('appUrl')}/sms`
})

// Handle incoming Twilio SMS webhook requests
router.post('/', validator, (request, response) => {
  // Create TwiML generation helper
  let twiml = new twilio.twiml.MessagingResponse()

  let user = request.body.From
  let bodyParts = request.body.Body.split(' ')
  let command = bodyParts[0].toLowerCase()
  let args = bodyParts.splice(1)

response.send(twiml);

    } else if (selectedOption == '2') {
      // Record your message
      twiml.say('Record your message after the tone.');
      twiml.record({
        action: '/voice/handle-record',
        maxLength: '30'
      });
      response.send(twiml);
    }
    response.send(redirectWelcome());
});

// POST: '/handle-record'
router.post('/handle-record', twilio.webhook({validate: false}), function (request, response) {
    var twiml = new twilio.TwimlResponse();
    twiml.say('Listen to your recorded message.');
    twiml.play(request.body.RecordingUrl);
    twiml.say('Goodbye.');
    response.send(twiml);
});

var redirectWelcome = function () {
    var twiml = new twilio.TwimlResponse();
    twiml.say("Returning to the main menu", {voice: "alice", language: "en-GB"});
    twiml.redirect("/voice");
    return twiml;
};


module.exports = router;

var express = require('express');
var router = express.Router();
var twilio = require('twilio');

// POST: '/voice'
router.post('/voice', twilio.webhook({validate: false}), function (request, response) {
    var twiml = new twilio.TwimlResponse();
    twiml.gather({
        action: "voice/handle-record",
        numDigits: "1",
        method: "POST"
    }, function (node) {
        node.play("http://howtodocs.s3.amazonaws.com/et-phone.mp3", {loop: 3});
    });
    response.send(twiml);
});

module.exports = router;

var twilio = require('twilio'),
    Message = require('../models/Message');

// Webhook middleware, check request signature
exports.webhook = twilio.webhook({
    // Only validate requests in production
    validate: process.env.NODE_ENV === 'production',

    // Manually configure the host and protocol used for webhook config - this
    // is the URL our Twilio number will hit in production
    host:'rev-answering-machine.herokuapp.com',
    protocol:'https'
});

// Handle incoming voice calls
exports.voice = function(request, response) {
    var twiml = new twilio.TwimlResponse();

    twiml.say('Hi there! Thanks for calling to wish Joe good luck this season. Please leave your message after the beep - you can end the message by pressing any button. Get ready!')
        .record({
            maxLength:120,

// You can find your Twilio Auth Token here: https://www.twilio.com/console
// Set at runtime as follows:
// $ TWILIO_AUTH_TOKEN=XXXXXXXXXXXXXXXXXXX node index.js
//
// This will not work unless you set the TWILIO_AUTH_TOKEN environment
// variable.

const twilio = require('twilio');
const app = require('express')();
const bodyParser = require('body-parser');
const VoiceResponse = require('twilio').twiml.VoiceResponse;
const MessagingResponse = require('twilio').twiml.MessagingResponse;

app.use(bodyParser.urlencoded({ extended: false }));

app.post('/voice', twilio.webhook(), (req, res) => {
  // Twilio Voice URL - receives incoming calls from Twilio
  const response = new VoiceResponse();

  response.say(
    `Thanks for calling!
     Your phone number is ${req.body.From}. I got your call because of Twilio´s
     webhook. Goodbye!`
  );

  res.set('Content-Type', 'text/xml');
  res.send(response.toString());
});

app.post('/message', twilio.webhook(), (req, res) => {
  // Twilio Messaging URL - receives incoming messages from Twilio
  const response = new MessagingResponse();

const http = require('http');
const express = require('express');
const router = express.Router();
const app = express();
const twilio = require('twilio');
const VoiceResponse = require('twilio').twiml.VoiceResponse;
const bodyParser = require('body-parser');

app.use(bodyParser.json());

// POST: '/voice/handle-gather'
router.post(
  '/handle-gather',
  twilio.webhook({ validate: false }),
  (req, res) => {
    const selectedOption = req.body.Digits;
    const twiml = new VoiceResponse();

    if (selectedOption == '1') {
      // Dial a new person
      twiml.dial('+13105551212');

      twiml.say('The call failed or the remote party hung up. Goodbye.');

      return res.send(twiml);
    } else if (selectedOption == '2') {
      // Record your message
      twiml.say('Record your message after the tone.');

      twiml.record({

function webhook() {
  log.warn("twilio webhook call"); // sky: doesn't run this
  if (twilio) {
    return Twilio.webhook();
  } else {
    log.warn("NO TWILIO WEB VALIDATION");
    return function(req, res, next) {
      next();
    };
  }
}

export default function(states: State.UsableState[], config: config): Express {
  // Set up express
  const app = express();

  // Parse twilio POST payloads, which come as urlencoded strings...
  // TODO: handle pre-parsed bodies
  app.use(bodyParser.urlencoded({ extended: false }));

  // Verify that incoming requests are coming from twilio by default or if set.
  // Note: this requires the properties on express's req object to match the
  // properties of the request as twilio sent it (i.e., protocol, host, etc.
  // can't have been rewritten internally).
  const { validate = true } = config.twilio;
  app.use(twilioWebhook(config.twilio.authToken, { validate: validate }));

  // Create a function we'll pass to makeMiddlewareAndFurl,
  // as it needs to be able to make a urlFor function too.
  const createUrlFor = createUrlForFromConfig(config.urlFor);

  // Set up our url fingerprinter. This will stay undefined if the user doesn't
  // opt in to any of our static file handling; if they do, we'll fill it with
  // the fingerprinting function returned by the static files module.
  let urlFingerprinter: fingerprintUrl | undefined;

  if (config.staticFiles) {
    // Create the middleware and url fingerprinter function that we're going
    // to use to serve static files. Save the calculated fingerprinting function.
    let serveStaticMiddlewares: Handler[];
    [serveStaticMiddlewares, urlFingerprinter] =
      makeMiddlewareAndFurl(config.staticFiles, createUrlFor);

res.send(twiml)
})

router.post('/recording', twilio.webhook(twilio_auth_token), function (req, res) {
  log.info(req.body.CallSid + '-> calls/recording')
  log.debug(req.body)

  var twiml = new twilio.TwimlResponse()

  enqueue_question(req.body)

  twiml.say('Let me think about that.').redirect('/calls/holding')
  res.send(twiml)
})

router.post('/answer', twilio.webhook(twilio_auth_token), function (req, res) {
  log.info(req.body.CallSid + '-> calls/answer')
  log.debug(req.body)

  var twiml = new twilio.TwimlResponse()

  twiml.say(answers[req.body.CallSid])
    .say('Do you have another question?')
    .record({timeout: 60, action: '/calls/recording'})

  res.send(twiml)
})

module.exports = router

function default_1(states, config) {
    const app = express();
    app.use(bodyParser.urlencoded({ extended: false }));
    const { validate = true } = config.twilio;
    app.use(twilio_1.webhook(config.twilio.authToken, { validate: validate }));
    const createUrlFor = urlFor_1.createUrlForFromConfig(config.urlFor);
    let urlFingerprinter;
    if (config.staticFiles) {
        let serveStaticMiddlewares;
        [serveStaticMiddlewares, urlFingerprinter] =
            staticFiles_1.default(config.staticFiles, createUrlFor);
        app.use(config.staticFiles.mountPath || "", serveStaticMiddlewares);
    }
    const createUrlForFromReq = createUrlFor(urlFingerprinter);
    states.forEach(thisState => {
        if (!State.isValidState(thisState)) {
            const stateAsString = State.stateToString(thisState);
            throw new Error("Invalid state provided: " + stateAsString);
        }
        if (State.isRoutableState(thisState)) {
            app.post(thisState.uri, function (req, res, next) {