Scent-terrific Smart Candle

//This is the Alexa Smart Home skill code used to control Smart Candles
//Users need to understand the following concepts before creating/modifying this skill:
// - AWS IoT Shadows: https://docs.aws.amazon.com/iot/latest/developerguide/iot-device-shadows.html
// - AWS IoT: https://docs.aws.amazon.com/iot/latest/developerguide/iot-thing-management.html
// - Alexa Smart Home Skill Development: https://developer.amazon.com/docs/smarthome/understand-the-smart-home-skill-api.html
//Please reach out to Darian Johnson (@darianbjohnson via Twitter) for questions


var AWS = require('aws-sdk');
var requestCall = require('request');

//Config variables for IoT Thing
const config = {};
config.IOT_BROKER_ENDPOINT = "XXX.iot.XXX.amazonaws.com";  // REST API endpoint for you IoT Devices
config.IOT_BROKER_REGION = "XXX";  // the region where you build your IoT Thing; for example, us-east-1 for the N. Virginia region

exports.handler = function (request, context) {

    //used when you ask Alexa to discover your devices
    if (request.directive.header.namespace === 'Alexa.Discovery' && request.directive.header.name === 'Discover') {
        var token = request.directive.payload.scope.token;

        //You can comment out the validateUser call if you plan to hard code your ThingName(s)
        validateUser(request, context, token, (userId) => {
            handleDiscovery(request, context, userId);
        });
    }

    //used when you ask Alexa to turn on/off your smart devices
    else if (request.directive.header.namespace === 'Alexa.PowerController') {
        if (request.directive.header.name === 'TurnOn' || request.directive.header.name === 'TurnOff') {
            log("DEBUG:", "TurnOn or TurnOff Request", JSON.stringify(request));
            handlePowerControl(request, context);
        }
    }

    //used when the Alexa App attempts to determine the state of a device
    else if (request.directive.header.namespace === 'Alexa') {
        if (request.directive.header.name === 'ReportState') {
            handleReportState(request, context);
        }
    }

    else{
        var responseHeader = request.directive.header;
        responseHeader.messageId = responseHeader.messageId + "-R";
        responseHeader.name = "ErrorResponse";
        var response = {
            context: contextResult,
            event: {
                header: responseHeader,
                endpoint: {
                    "endpointId": request.directive.endpoint.endpointId
                },
                payload: {
                    "type": "INVALID_DIRECTIVE",
                    "message": "That command is not valid for this device."
                }
            }
        };
        log("DEBUG", "ERROR ", JSON.stringify(response));
        context.succeed(response);
    }

    function handleDiscovery(request, context, userId) {
        //getApplicances passes in a userId (from the validateUser function) and returns all devices
        //associated with a userID. You can remove this call and hardcode the return values.
        //See https://github.com/alexa/alexa-smarthome/blob/master/sample_messages/Discovery/Discovery.response.json
        //for an example of a hardcoded response.

        getApplicances(userId, (errCode, endpoints) => {
            var payload = {
                "endpoints": endpoints
            };
            var header = request.directive.header;
            header.name = "Discover.Response";
            log("DEBUG", "Discovery Response: ", JSON.stringify({ header: header, payload: payload }));
            context.succeed({ event: { header: header, payload: payload } });
        });
    }

    function log(message, message1, message2) {
        console.log(message + message1 + message2);
    }

    //
    function handlePowerControl(request, context) {

        var endpointId = request.directive.endpoint.endpointId; // get device ID for requested device
        var requestMethod = request.directive.header.name; //used to determine if device should be on or off
        var requestToken = request.directive.endpoint.scope.token; // get user token pass in request
        var powerResult;
        var desiredState;

        if (requestMethod === "TurnOn") {
            powerResult = "ON";
            desiredState = true;
        }
        else if (requestMethod === "TurnOff") {
            powerResult = "OFF";
            desiredState = false;
        }

        //this updates the IoT ShadowThing, based on the desired state (on or off)
        handleDevice(endpointId, desiredState, (result) => {

            var d = new Date();
            var isoD = d.toISOString();
            var contextResult = {
                "properties": [
                    {
                        "namespace": "Alexa.PowerController",
                        "name": "powerState",
                        "value": powerResult,
                        "timeOfSample": isoD,
                        "uncertaintyInMilliseconds": 50
                    }, 
                    {
                        "namespace": "Alexa.EndpointHealth",
                        "name": "connectivity",
                        "value": {
                            "value": "OK"
                        },
                        "timeOfSample": isoD,
                        "uncertaintyInMilliseconds": 0
                    }
                ]
            };
            var responseHeader = request.directive.header;
            var responseEndpoint = request.directive.endpoint;
            responseHeader.namespace = "Alexa";
            responseHeader.name = "Response";
            responseHeader.messageId = responseHeader.messageId + "-R";
            var response = {
                context: contextResult,
                event: {
                    header: responseHeader,
                    endpoint: responseEndpoint,
                    payload: {}
                }

            };
            //log("DEBUG", "Alexa.PowerController ", JSON.stringify(response));
            //context.succeed(response);

            //Send and error back if the Shadow Device Reported state is not updated in 6 seconds
            var timeoutObj = setTimeout(() => {
                console.log('timeout beyond time');
                handleError(request, context);
            }, 7000);


            //Check the Shadow Every 0.3 sec to see if the update has occured; if so, send success message
            var intervalObj = setInterval(() => {
                getDeviceStatus(endpointId,(results)=>{
                    if (results === powerResult){
                        log("DEBUG", "Alexa.PowerController ", JSON.stringify(response));
                        context.succeed(response);
                    }
                });
            }, 300);
        });
    }

    //this lets the Alexa app know if the device is on or off   
    function handleReportState(request, context) {
        var endpointId = request.directive.endpoint.endpointId;
        getDeviceStatus(endpointId, (powerResult) => {

            if (powerResult === "ERR") {
                handleError(request, context);
            }
            else {

                var d = new Date();
                var isoD = d.toISOString();
                var contextResult = {
                    "properties": [
                        {
                            "namespace": "Alexa.PowerController",
                            "name": "powerState",
                            "value": powerResult,
                            "timeOfSample": isoD, 
                            "uncertaintyInMilliseconds": 50
                        }
                    ]
                };

                var responseHeader = request.directive.header;
                responseHeader.messageId = responseHeader.messageId + "-R";
                responseHeader.name = "StateReport";
                var response = {
                    context: contextResult,
                    event: {
                        header: responseHeader,
                        payload: {}
                    }
                };
                log("DEBUG", "ReportState ", JSON.stringify(response));
                context.succeed(response);
            }

        });
    }

    //this handles errors if the device is unreachable
    function handleError(request, context) {
        var responseHeader = request.directive.header;
        responseHeader.messageId = responseHeader.messageId + "-R";
        responseHeader.name = "ErrorResponse";
        var response = {
            context: contextResult,
            event: {
                header: responseHeader,
                endpoint: {
                    "endpointId": request.directive.endpoint.endpointId
                },
                payload: {
                    "type": "ENDPOINT_UNREACHABLE",
                    "message": "Unable to reach device because it appears to be offline."
                }
            }
        };
        log("DEBUG", "ERROR ", JSON.stringify(response));
        context.succeed(response);

    }

    //this function is needed if you plan to authenticate against a device cloud
    //You can remove/ignore this function if you plan to hard code values
    function validateUser(request, context, token, callback) {
        if (token === 'access-token-from-skill') {
            callback('test1');
        } else {
            var amznProfileURL = 'https://api.amazon.com/user/profile?access_token=';
            amznProfileURL += token;
            requestCall(amznProfileURL, function (error, response, body) {
                if (error) {
                    var responseHeader = request.directive.header;
                    responseHeader.messageId = responseHeader.messageId + "-R";
                    responseHeader.name = "ErrorResponse";
                    var response = {
                        context: contextResult,
                        event: {
                            header: responseHeader,
                            payload: {
                                "type": "INVALID_AUTHORIZATION_CREDENTIAL",
                                "message": "The authorization credential provided by Alexa is invalid. Disable and re-enable the skill."
                            }
                        }
                    };
                    log("DEBUG", "ERROR ", JSON.stringify(response));
                    context.succeed(response);
                } else {
                    if (response.statusCode == 200) {
                        var parsedBody = JSON.parse(body);
                        console.log(parsedBody.user_id);
                        callback(parsedBody.user_id);
                    } else {
                        var responseHeader = request.directive.header;
                        responseHeader.messageId = responseHeader.messageId + "-R";
                        responseHeader.name = "ErrorResponse";
                        var response = {
                            context: contextResult,
                            event: {
                                header: responseHeader,
                                payload: {
                                    "type": "EXPIRED_AUTHORIZATION_CREDENTIAL",
                                    "message": "The authorization credential provided by Alexa has expired. Disable and re-enable the skill."
                                }
                            }
                        };
                        log("DEBUG", "ERROR ", JSON.stringify(response));
                        context.succeed(response);
                    }
                }
            });
        }
    
    }
};

//this function returns all the devices associated with an authenticaed user (listed in a DynamoDB table)
//You can remove/ignore this function if you plan to hard code values
function getApplicances(userId, callback) {

    var params = {
        TableName: "WaxOn_Appliances",
        IndexName: "userId-index",
        KeyConditionExpression: "#userId = :userId",
        ExpressionAttributeNames: {
            "#userId": "userId"
        },
        ExpressionAttributeValues: {
            ":userId": userId
        }
    };

    var docClient = new AWS.DynamoDB.DocumentClient();

    var endpoints = [];

    var p = new Promise((resolve, reject) => {
        docClient.query(params, function (err, data) {
            if (err) {
                console.log(err);
                reject(endpoints);
            } else {
                data.Items.forEach(function (item) {
                    var endpointDetails = {};
                    endpointDetails.endpointId = item.applianceId;
                    endpointDetails.description = item.description;
                    endpointDetails.friendlyName = item.friendlyName;
                    endpointDetails.displayCategories = [item.displayCategories];
                    endpointDetails.manufacturerName = "WaxOn Smart Candle - DIY";
                    endpointDetails.capabilities =
                        [
                            {
                                "type": "AlexaInterface",
                                "interface": "Alexa",
                                "version": "3"
                            },
                            {
                                "interface": "Alexa.PowerController",
                                "version": "3",
                                "type": "AlexaInterface",
                                "properties": {
                                    "supported": [{
                                        "name": "powerState"
                                    }],
                                    "retrievable": true,
                                    "proactivelyReported": false
                                    /*"proactivelyReported": true, "retrievable": true */
                                }
                            }
                        ];
                    endpoints.push(endpointDetails);
                });

                resolve(endpoints);
            }
        });
    });

    p.then(value => {

        if (value.length < 0) {
            callback(0, null);
        }
        else {
            callback(1, value);
        }

    }, reason => {
        console.log(reason); // Error!
        callback(-1, null);
    });
}

//This function updates the IoT Shadow Thing to turn the desired state on or off
//the ESP8266 will update the ShadowThing to reflect the "reported" state as on/off
//after it recieves the ShadowThing Update
function handleDevice(endpointId, desiredState, callback) {
    // update AWS IOT thing shadow
    AWS.config.region = config.IOT_BROKER_REGION;

    var param = { "on": desiredState }

    var paramsUpdate = {
        "thingName": endpointId,
        "payload": JSON.stringify(
            {
                "state":
                    {
                        "desired": param
                    }
            }
        )
    };

    var iotData = new AWS.IotData({ endpoint: config.IOT_BROKER_ENDPOINT });

    iotData.updateThingShadow(paramsUpdate, function (err, data) {
        if (err) {
            console.log("an error");
            callback("not ok");
        }
        else {
            console.log("success");
            callback("ok");
        }
    });

}

//This function returns the current state (on/off) of the device
function getDeviceStatus(endpointId, callback) {
    // update AWS IOT thing shadow
    AWS.config.region = config.IOT_BROKER_REGION;

    var params = {
        "thingName": endpointId
    };

    var iotData = new AWS.IotData({ endpoint: config.IOT_BROKER_ENDPOINT });

    iotData.getThingShadow(params, function (err, data) {
        if (err) {
            console.log(err);
            callback("ERR");
        }
        else {
            var results = JSON.parse(data.payload)
            var deviceState = results.state.reported.on;
            if (!deviceState) {
                callback("OFF");
            } else {
                callback("ON");
            }
        }
    });

}

//Code that is installed on ESP8266 via Mongoose OS


load("api_aws.js");
load('api_gpio.js');

let ledPin = 0; //led indicator on ESP8266 device
let buttonPin = 2; //button
let prominiPin = 15; //connected to Pro Mini to indicate if the LED should be on or off
let state = { on: false, counter: 0 };  // device state: shadow metadata

GPIO.set_mode(ledPin,GPIO.MODE_OUTPUT);
GPIO.set_mode(prominiPin,GPIO.MODE_OUTPUT);


// Upon startup, report current actual state, "reported"
// When cloud sends us a command to update state ("desired"), do it
AWS.Shadow.setStateHandler(function(data, event, reported, desired, reported_metadata, desired_metadata) {
  if (event === AWS.Shadow.CONNECTED) {
    AWS.Shadow.update(0, {reported: state});  // Report device state
  } else if (event === AWS.Shadow.UPDATE_DELTA) {
    for (let key in state) {
      if (desired[key] !== undefined) state[key] = desired[key];
    }
    AWS.Shadow.update(0, {reported: state});  // Report device state
  }
  print(JSON.stringify(reported), JSON.stringify(desired));
  if (!reported.on){
    GPIO.write(ledPin,1); 		//ESP8266 Light off
    GPIO.write(prominiPin,0); 	//Candle off
  }else{
    GPIO.write(ledPin,0);		//ESP8266 Light on
    GPIO.write(prominiPin,1); 	//Candle on
  }
}, null);

// On a button press, update press counter via the shadow
GPIO.set_button_handler(buttonPin, GPIO.PULL_UP, GPIO.INT_EDGE_NEG, 200, function() {
  state.on = !state.on;
  AWS.Shadow.update(0, {desired: {on: state.on, counter: state.counter + 1}}); //update ShadowThing to turn on/off device (desired state)
}, null);