Smart Kettle with Alexa [Updated To v3 API]

var https = require('https');

var serialPortControllerId = "SAKA_Kettle_10102017";

var particleServer = "api.particle.io";
var particlePath = "/v1/devices/";
var particleId = "your_device_id"; //you can find this in the particle IDE console under devices

var powerOn = "on";
var powerOff = "off";

exports.handler = function(event, context) {

    log('Input', event);

    switch (event.directive.header.namespace) {
        
        /**
         * The namespace of "Discovery" indicates a request is being made to the lambda for
         * discovering all appliances associated with the customer's appliance cloud account.
         * can use the accessToken that is made available as part of the payload to determine
         * the customer.
         */
        case 'Alexa.Discovery':
            handleDiscovery(event, context);
            break;

        case 'Alexa.PowerController':
            handleControl(event, context);
            break;

        default:
            log('Err', 'No supported namespace: ' + event.directive.header.namespace);
            context.fail('Something went wrong');
            break;
    }
};

/**
 * This method is invoked when we receive a "Discovery" message from Alexa Connected Home Skill.
 * We are expected to respond back with a list of appliances that we have discovered for a given
 * customer. 
 */
function handleDiscovery(event, context) {

    var payload = {
        "endpoints":[
            {
            "endpointId": serialPortControllerId,
            "friendlyName": "Kettle",
            "description": "Smart Kettle by SAKA (c) 2017",
            "manufacturerName": "SAKA",
            "displayCategories": ["OTHER"],
            "cookie": {
                "deviceId" : particleId
                },
            "capabilities": [
            {
                "type": "AlexaInterface",
                "interface": "Alexa.PowerController",
                "version": "1.0",
                "properties": {
                    "supported" : [
                        {
                            "name": "powerState"
                        }
                    ],
                    "proactivelyReported": true,
                    "retrievable": true
                }
            }
        ]}
    ]};


    /**
     * Craft the final response back to Alexa Connected Home Skill. This will include all the 
     * discoverd appliances.
     */
    var header = event.directive.header;
    header.name = "Discover.Response";
    context.succeed({ event: {
    header: header, payload: payload
    } });

    //log('Discovery', result);

}

/**
 * Control events are processed here.
 * This is called when Alexa requests an action (IE turn off appliance).
 */
function handleControl(event, context) {
    var namespace = event.directive.header.namespace;
    var messageId = event.directive.header.messageId;
    var correlationToken = event.directive.header.correlationToken;
    var accessToken = event.directive.endpoint.scope.token;
    var endpointId = event.directive.endpoint.endpointId;
    var deviceId = event.directive.endpoint.cookie.deviceId;
    var name = "";
    var value = "";
    var UTCDate = new Date();
    var jsonDate = JSON.stringify(UTCDate);
    var strDate = JSON.parse(jsonDate);  
    var funcName = "KettleOnOff";
    if (namespace === "Alexa.PowerController") {
        
        var param = "";
        var index = "0";
        var executeParticle = true;

        if (namespace === "Alexa.PowerController") {
            if(event.directive.header.name == "TurnOn"){
                kettleCommand = powerOn;
                name = "powerState";
                value = "ON";
            }
            else if(event.directive.header.name == "TurnOff"){
                kettleCommand = powerOff;            
                name = "powerState";
                value = "OFF";
            }
        }

        if(deviceId == particleId){
            index = "0";
        }

        param = kettleCommand;
        
        var options = {
            hostname: particleServer,
            port: 443,
            path: particlePath + deviceId + "/" + funcName,
            method: 'POST',
            headers: {
                'Content-Type': 'application/x-www-form-urlencoded'
            }
        };
        
        log(options);
        
        var data = "access_token=" + accessToken + "&" + "args=" + param;
        
        log(data);

        var serverError = function (e) {
            log('Error', e.message);
            context.fail(generateControlError(event, 'ENDPOINT_UNREACHABLE', 'Unable to connect to server'));
        };

        if (executeParticle) {
            var callback = function(response) {
                var str = '';
    
                response.on('data', function(chunk) {
                    str += chunk.toString('utf-8');
                });
    
                response.on('end', function() {
                    log('Return Value');
                    log(str);
                    
                var result = {
                    "context": {
                        "properties": [ {
                            "namespace": namespace,
                            "name": name,
                            "value": value,
                            "timeOfSample": strDate,
                            "uncertaintyInMilliseconds": 500
                            } ]
                        },
                          "event": {
                            "header": {
                              "namespace": "Alexa",
                              "name": "Response",
                              "payloadVersion": "3",
                              "messageId": messageId,
                              "correlationToken": correlationToken
                            },
                            "endpoint": {
                              "scope": {
                                "type": "BearerToken",
                                "token": accessToken
                              },
                              "endpointId": endpointId
                            },
                            "payload": {}
                          }
                        };
                    context.succeed(result);
                    });
    
                response.on('error', serverError);
            };
    
            var req = https.request(options, callback);
                
            req.on('error', serverError);
            
            req.write(data);
            req.end();
        }
    }
}

/**
 * Utility functions.
 */
function log(title, msg) {
    console.log(title + ": " + msg);
}

function generateControlError(event, code, description) {
    var messageId = event.directive.header.messageId;
    var correlationToken = event.directive.header.correlationToken;
    var accessToken = event.directive.endpoint.scope.token;
    var endpointId = event.directive.endpoint.endpointId;
    var response = {
        "header": {
            "namespace": "Alexa",
            "name": "ErrorResponse",
            "messageId": messageId,
            "correlationToken": correlationToken,
            "payloadVersion": "3"
            },
            "endpoint":{
                "scope":{
                    "type":"BearerToken",
                    "token":accessToken
                },
                "endpointId":endpointId
            },
            "payload": {
                "type": code,
                "message": description
            }
        };

    var result = { event : {response}};

    return result;
}

//Function to format the volume with leading zeros
function pad(num, size) {
    var s = "000" + num;
    return s.substr(s.length-size);
}