You will then be at a "Configure Function" screen:

Configure Function (saveAndAlert Function)

console.log('Loading saveAndAlert function');

/* Twilio calls this (our callback, via URL) with these parameters:
  RecordingUrl:        the URL of the recorded audio
  RecordingDuration:   the duration of the recorded audio (in seconds)
  Digits:              the key (if any) pressed to end the recording or 'hangup' if the caller hung up

  This Lambda is responsible for:
    1) Authenticating the Twilio call
    2) Gathering the Voicemail recording from Twilio and saving locally
        Twilio will return a recording in binary WAV audio format by default. To request the recording
        in MP3 format, append ".mp3" to the RecordingUrl.
    3) Sending an SMS to me so we know about the call

    Test Configuration:
    {
      "AccountSid": "YourAccountKeyHere",
      "RecordingUrl": "http://foo.com/sample_voicemail",
      "CallerName": "Test Caller"
    }

*/

var AWS         = require('aws-sdk');
var https       = require('https');
var querystring = require('querystring');


voicemailFilename = function(caller_name) {
    // Make a nice yyyy-mm-dd-hh-mm-caller_name file
    // caller_name:  "SMITH JOHN"
    var current_time = new Date();
    var filename = current_time.getFullYear().toString() + "-" +
              (current_time.getMonth()+1).toString() + "-" +
              current_time.getDate().toString() + "-" +
              current_time.getHours().toString() + "-" +
              current_time.getMinutes().toString() + "-" +
              current_time.getSeconds().toString() + "-" +
              caller_name.replace(" ","_");
    return filename;
    };


smsAlerter = function(error, message, environment, context, callback, callback_message) {
    callback = (typeof callback === 'function') ? callback : function() {};

    var postData = querystring.stringify({
      'From' : environment.twilio.phoebe_number,
      'To'   : environment.twilio.alert_phone_number,
      'Body' : message
    });
    console.log("(smsAlerter) message:" + message);

    // See https://nodejs.org/dist/latest-v4.x/docs/api/https.html#https_https_request_options_callback
    var options = {
        hostname: 'api.twilio.com',
        method: 'POST',
        path: '/2010-04-01/Accounts/' + environment.twilio.account_sid + '/Messages.json',
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded',
            'Content-Length': postData.length
        },
        auth: environment.twilio.account_sid + ':' + environment.twilio.auth_token
    };
    console.log("(smsAlerter) options.path:" + options.path);

    var request = https.request(options, function (response) {
      console.log('(smsAlerter) STATUS: ' + response.statusCode);
      response.setEncoding('utf8');
      response.on('data', function (chunk) {
        console.log('(smsAlerter) response data event');
      });
      response.on('end', function () {
        console.log('(smsAlerter) response end event. Calling callback');
        callback(null, callback_message, environment, context);
      });
      response.on('error', function (error) {
        console.log('(smsAlerter) response Error received: ' + error);
      });
    });
    request.on('error', function (e) {
      console.log('(smsAlerter) problem with request: ' + e.message);
    });
    request.write(postData);
    request.end();
    console.log("(smsAlerter) Have ended the request");
};


twimlCallback = function(error, message, environment, context) {
    var twimlHeader       = '<?xml version="1.0" encoding="UTF-8"?>';
    var responseHeader    = '<Response>';
    var responseFooter    = '</Response>';
    var sayHeader         = '<Say voice="alice" language="en-gb">';
    var sayFooter         = '</Say>';
    var smsHeader         = '<Sms from="' + environment.twilio.phoebe_number + '" to="' + environment.twilio.alert_phone_number + '">';
    var smsFooter         = '</Sms>';

    if (error) {
        console.log('(twimlCallback) ERROR');
    }
    else {
        console.log('(twimlCallback) returning success and twiml');
        var full_callback_message = twimlHeader + responseHeader + sayHeader + message + sayFooter + responseFooter;
        context.succeed(full_callback_message);
    }
};


exports.handler = function(event, context) {
    console.log( "event", event );
    var recording_url           = event.RecordingUrl;
    var caller_name             = event.CallerName;

    console.log("(handler) recording_url:" + recording_url);

    var s3 = new AWS.S3();
    var param = {Bucket: 'dc-cloud-phoebe', Key: 'config/environment.json'};
    s3.getObject(param, function(err, auth_data) {
        if(err) {
            context.fail("Failure reading authentication file - S3 Error");
            console.log(err, err.stack);
        }
        else {
            console.log("(handler) Parsing Environment file");
            var environment = JSON.parse(auth_data.Body);
            if (event.AccountSid == environment.twilio.account_sid)
            {
                var voicemail_file = {Bucket: 'dc-cloud-phoebe/voicemails', Key: voicemailFilename(caller_name), Body: recording_url};
                var sms_notice = 'Saving voicemail';
                var recording_notice = 'Recording URL';

                console.log("(handler) Starting s3 Upload: " + caller_name);
                s3.upload(voicemail_file, function(err, voicemail_data) {
                    if (err) {
                        console.log("(handler) S3 ERROR:" + err, err.stack);
                        var bummer = 'So sorry, I had trouble saving the voicemail';
                        sms_notice = 'Error saving voicemail from ' + caller_name;
                        smsAlerter(null, sms_notice, environment, twimlCallback(null, bummer, environment, context));
                    }
                    else {
                        console.log('(handler) Uploaded file:' + voicemail_data);
                        var inform_voicemail_sent = 'I have sent your voicemail to Dave. Bye!';

                        // We send TWO text messages in case the message containing URL causes issues on the receiving phone
                        sms_notice = 'Call from ' + caller_name;
                        recording_notice = 'URI: ' + recording_url;
                        console.log('(handler) Defining smsCallDetails');

                        var formatTwimlResponse = function(err, message, environment, context) {
                            console.log("(smsCallDetails) Calling twimlCallback to render final Twiml");
                            twimlCallback(err, message, environment, context);
                        };

                        var smsCallDetails = function(err, message, environment, context) {
                            console.log("(smsCallDetails) Calling smsAlerter with recording_notice");
                            smsAlerter(null, recording_notice, environment, context, formatTwimlResponse, inform_voicemail_sent);
                        };

                        console.log('(handler) Calling smsAlerter with sms_notice');
                        smsAlerter(null, sms_notice, environment, context, smsCallDetails, null);
                    }
                });
            }
            else {
                context.fail("(handler) Authentication Failed");
            }
        }
    });
}

Lambda Function Handler and Role (saveAndAlert Function)

Advanced Settings (saveAndAlert Function)

We are leaving the "Advanced Settings" at their defaults

Review (saveAndAlert Function)

Double check the settings and click "Create Function"

Testing and troubleshooting when using Lambda, the API Gateway, and Twilio is made much, much easier if you test each component individually before trying to integrate the pieces (sound familiar?). First let's test the answerPhone function.

Testing the answerPhone Lambda

Go back to the Lambda main screen, click on your "answerPhone" function, and under Actions choose "Test Function". You will be brought to an "Input test event" screen. Paste the following code (which is also setup as a comment block in the answerPhone function), and Modify the "AccountSid" to be the same Twilio Sid you put in your environments.json file:

{
  "AccountSid": "PlaceyourTwilioSidhere",
  "CalledCity": "Denver",
  "CallerCity": "Chicago"
}

For this test the AccountSid is the only thing that really matters. Click "Save and Test" You will see "executing function" and then, if your Lambda ran without errors, you will see "Execution Result: succeeded" and the output. Your Lambda function output should be "Twiml" (an XML variant) and should look something like this:

"<?xml version=\"1.0\" encoding=\"UTF-8\"?><Response><Pause length=\"2\"/><Say voice=\"alice\" language=\"en-gb\">
Hello, I'm Phoebe, the Cloud-based Assistant of Dave Collins.
Please leave a voicemail and Dave will get back to you as soon as possible.
</Say><Record action=\"https://5....a.execute-api.us-east-1.amazonaws.com/prod/voicemail_saver\"
method=\"GET\" maxLength=\"20\" finishOnKey=\"*\"/><Say>I did not receive a recording</Say></Response>"

If you don't get that successful response, check the "Log Output" section. Some common problems at this point are:

Remember, at this point you are not using the API gateway, nor are you using Twilio. You are just verifying that your Node.js Lambda function is running without errors. This might be a good time to mention our unit tests. If you view the github repository for this project, you will see that we have some Mocha tests for the Node.js. Unfortunately, "I suck at Mocha" (Sorry - Most of my testing is done in Rspec for rails) so the tests are very basic. Please log a Pull Request on the project if you can improve the tests!

Testing the saveAndAlert Lambda

Similar to the answerPhone testing steps above, but you'll need a different JSON structure. This is the callback method that Twilio will be calling. Twilio will provide the all-important "RecordingUrl" and "CallerName" parameters that this method will be using.

{
  "AccountSid": "YourTwilioAccountSid",
  "RecordingUrl": "http://foo.com/sample_voicemail",
  "CallerName": "Test Caller"
}

Just as with the answerPhone lambda, all you are looking for here is basic success and a TWIML response.

When each test is successful, choose Actions | Publish New Version

Now we are getting to the fun part! We need to properly expose our two Lambdas as Externally acessible API's using AWS API Endpoint

Setup the API Gateway for the answerPhone Lambda

Let's map our answerPhone Lambda function to an external API Endpoint, so that Twilio can hit our Lambda function when somebody calls us.

Choose Services | Amazon API Gateway and under API's you should see the DigitalAssistant we created when we setup the first (answerPhone) Lambda. Click on your DigitalAssistant API and then "resources".

If all went well, you should have two resources here: "answerPhone" and "saveAndAlert". I have had times during testing where one or more of the resources did not get automatically added, and some times where a "null" resource showed up. No big deal: If you see a "null" resource just click on it and choose Actions | Delete Resource.

If one or more of your resources are missing, just choose Actions | Create Resource , select type "GET" and click the save (checkmark) icon... Then follow the instructions below for each resource.

Since you linked answerPhone first you'll probably see the answerPhone resource here, we will need to modify several components of this resource:

Click on your answerPhone GET handler to pull up the Resource diagram. There are four sections that we need to visit to double-check settings: "Method Request", "Integration Request", "Integration Response", and "Method Response"

Method Request (answerPhone)

Integration Request (answerPhone)

Under "Body Mapping Templates", Since Twilio will be sending us a GET request with parameters, and we are expecting JSON in our Node.js Lambda's, ensure your settings are as follows:

                    {
                      "AccountSid" : "$input.params('AccountSid')",
                      "CalledCity" : "$input.params('CalledCity')",
                      "CallerCity" : "$input.params('CallerCity')"
                    }
                

Integration Response (answerPhone)

Under the "200" Method Response Status, "Body Mapping Templates", you may already have a Mapping Template with the content-type of "application/x-www-form-urlencoded" This needs to be changed. When you are finished we want only one Body Mapping Template:

ensure your settings are as follows: - Content-Type: application/json - In the main body, enter the text below

    #set($inputRoot = $input.path('$'))
    $inputRoot

Method Response (answerPhone)

Twilio needs and expects to receive TWIML (SML) back from us, not JSON (I'm eagerly awaiting Twilio supporting JSON responses instead of this XML variant). In the meantime, we need to setup Response Models for 200

• Response Models for 200: Add "application/xml" and model: Empty

If this resource is missing, just choose Actions | Create Resource, type "saveAndAlert" and click the save (checkmark) icon.

Make sure the saveAndAlert resource has a "GET" method: Click Actions | Create Method, choose GET and click the save (checkbox) icon.

Path: /saveAndAlert

Now highlight it and create a GET method

/saveAndAlert - GET - Setup

click Save, and OK the new permission to get to the resource diagram

Click on your saveAndAlert GET handler to pull up the Resource diagram. There are four sections that we need to visit to double-check settings: "Method Request", "Integration Request", "Integration Response", and "Method Response"

Method Request (saveAndAlert)

Integration Request (SaveAndAlert)

Under "Body Mapping Templates", we need to setup a mapping template Since Twilio will be sending us a GET request, and we are expecting JSON in our Node.js Lambda's, ensure your settings are as follows:

                    {
                      "AccountSid" : "$input.params('AccountSid')",
                      "RecordingUrl" : "$input.params('RecordingUrl')",
                      "CallerName" : "$input.params('CallerName')"
                    }