Agent

#require "Salesforce.class.nut:1.1.0"
#require "Rocky.class.nut:1.2.3"

#require "bullwinkle.class.nut:2.3.0"
#require "promise.class.nut:3.0.0"

// EXTEND SALESFORCE CLASS TO HANDLE OAUTH 2.0
// ----------------------------------------------------------
class SalesforceOAuth2 extends Salesforce {

    _login = null;

    constructor(consumerKey, consumerSecret, loginServiceBase = null, salesforceVersion = "v40.0") {
        _clientId = consumerKey;
        _clientSecret = consumerSecret;

        if ("Rocky" in getroottable()) {
            _login = Rocky();
        } else {
            throw "Unmet dependency: SalesforceOAuth2 requires Rocky";
        }

        if (loginServiceBase != null) _loginServiceBase = loginServiceBase;
        if (salesforceVersion != null) _version = salesforceVersion;

        getStoredCredentials();
        defineLoginEndpoint();
    }

    function getStoredCredentials() {
        local persist = server.load();
        local oAuth = {};
        if ("oAuth" in persist) oAuth = persist.oAuth;

        // Load credentials if we have them
        if ("instance_url" in oAuth && "access_token" in oAuth) {
            // Set the credentials in the Salesforce object
            setInstanceUrl(oAuth.instance_url);
            setToken(oAuth.access_token);

            // Log a message
            server.log("Loaded OAuth Credentials!");
            server.log(oAuth.instance_url);
        }
    }

    function defineLoginEndpoint() {
        // Define log in endpoint for a GET request to the agent URL
        _login.get("/", function(context) {

            // Check if an OAuth code was passed in
            if (!("code" in context.req.query)) {
                // If it wasn't, redirect to login service
                local location = format("%s/services/oauth2/authorize?response_type=code&client_id=%s&redirect_uri=%s", _loginServiceBase, _clientId, http.agenturl());
                context.setHeader("Location", location);
                context.send(302, "Found");

                return;
            }

            // Exchange the auth code for inan OAuth token
            getOAuthToken(context.req.query["code"], function(err, resp, respData) {
                if (err) {
                    context.send(400, "Error authenticating (" + err + ").");
                    return;
                }

                // If it was successful, save the data locally
                local persist = { "oAuth" : respData };
                server.save(persist);

                // Set/update the credentials in the Salesforce object
                setInstanceUrl(persist.oAuth.instance_url);
                setToken(persist.oAuth.access_token);

                // Finally - inform the user we're done!
                context.send(200, "Authentication complete - you may now close this window");
            }.bindenv(this));
        }.bindenv(this));
    }

    // OAuth 2.0 methods
    function getOAuthToken(code, cb) {
        // Send request with an authorization code
        _oauthTokenRequest("authorization_code", code, cb);
    }

    function refreshOAuthToken(refreshToken, cb) {
        // Send request with refresh token
        _oauthTokenRequest("refresh_token", refreshToken, cb);
    }

    function _oauthTokenRequest(type, tokenCode, cb = null) {
        // Build the request
        local url = format("%s/services/oauth2/token", _loginServiceBase);
        local headers = { "Content-Type": "application/x-www-form-urlencoded" };
        local data = {
            "grant_type": type,
            "client_id": _clientId,
            "client_secret": _clientSecret,
        };

        // Set the "code" or "refresh_token" parameters based on grant_type
        if (type == "authorization_code") {
            data.code <- tokenCode;
            data.redirect_uri <- http.agenturl();
        } else if (type == "refresh_token") {
            data.refresh_token <- tokenCode;
        } else {
            throw "Unknown grant_type";
        }

        local body = http.urlencode(data);

        http.post(url, headers, body).sendasync(function(resp) {
            local respData = http.jsondecode(resp.body);
            local err = null;

            // If there was an error, set the error code
            if (resp.statuscode != 200) err = data.message;

            // Invoke the callback
            if (cb) imp.wakeup(0, function() { cb(err, resp, respData); });
        });
    }
}


/***************************************************************************************
 * SmartFrigDataManager Class:
 *      Handle incoming device readings
 *      Set sensor threshold values
 *      Set callback handlers for events and streaming data
 *      Check for temperature, humidity, and door events
 *      Average temperature and humidity readings
 **************************************************************************************/
class SmartFrigDataManager {

    // Default settings
    static DEFAULT_LX_THRESHOLD = 50; // LX level indicating door open
    static DEFAULT_TEMP_THRESHOLD = 11;
    static DEFAULT_HUMID_THRESHOLD = 70;

    // NOTE: changing the device reading or reporting intervals will impact timing of event and alert conditions
    static DOOR_OPEN_ALERT = 10; // Number of reading cycles before activating a door alert (currently 30s: DOOR_OPEN_ALERT * device reading interval = seconds before sending door alert)
    static CLEAR_DOOR_OPEN_EVENT = 180; // Clear door open event after num seconds (prevents temperature or humidity alerts right after is opened)
    static TEMP_ALERT_CONDITION = 300; // Number of seconds the temperature must be over threshold before triggering event
    static HUMID_ALERT_CONDITION = 300; // Number of seconds the humidity must be over threshold before triggering event

    // Class variables
    _bull = null;

    // Threshold
    _tempThreshold = null;
    _humidThreshold = null;
    _lxThreshold = null;
    _thresholdsUpdated = null;

    // Alert flags and counters
    _doorOpenTS = null;
    _doorOpenCounter = null;
    _doorOpenAlertTriggered = null;
    _tempAlertTriggered = null;
    _humidAlertTriggered = null;
    _tempEventTime = null;
    _humidEventTime = null;

    // Event handlers
    _doorOpenHandler = null;
    _streamReadingsHandler = null;
    _tempAlertHandler = null;
    _humidAlertHandler = null;

    /***************************************************************************************
     * Constructor
     * Returns: null
     * Parameters:
     *      bullwinkle : instance - of Bullwinkle class
     **************************************************************************************/
    constructor(bullwinkle) {
        _bull = bullwinkle;
        setThresholds(DEFAULT_TEMP_THRESHOLD, DEFAULT_HUMID_THRESHOLD, DEFAULT_LX_THRESHOLD);

        _doorOpenCounter = 0;

        openListeners();
    }

     /***************************************************************************************
     * openListeners
     * Returns: this
     * Parameters: none
     **************************************************************************************/
    function openListeners() {
        _bull.on("readings", _readingsHandler.bindenv(this));
        _bull.on("lxThreshold", _lxThresholdHandler.bindenv(this));
        return this;
    }

    /***************************************************************************************
     * setThresholds
     * Returns: null
     * Parameters:
     *      temp : integer - new tempertature threshold value
     *      humid : integer - new humid threshold value
     *      lx : integer - new light level door  value
     **************************************************************************************/
    function setThresholds(temp, humid, lx) {
        _tempThreshold = temp;
        _humidThreshold = humid;
        _lxThreshold = lx;
        _thresholdsUpdated = true;
    }

    /***************************************************************************************
     * setDoorOpenHandler
     * Returns: null
     * Parameters:
     *      cb : function - called when door open alert triggered
     **************************************************************************************/
    function setDoorOpenHandler(cb) {
        _doorOpenHandler = cb;
    }

    /***************************************************************************************
     * setStreamReadingsHandler
     * Returns: null
     * Parameters:
     *      cb : function - called when new reading received
     **************************************************************************************/
    function setStreamReadingsHandler(cb) {
        _streamReadingsHandler = cb;
    }

    /***************************************************************************************
     * setTempAlertHandler
     * Returns: null
     * Parameters:
     *      cb : function - called when temperature alert triggerd
     **************************************************************************************/
    function setTempAlertHandler(cb) {
        _tempAlertHandler = cb;
    }

    /***************************************************************************************
     * setHumidAlertHandler
     * Returns: null
     * Parameters:
     *      cb : function - called when humidity alert triggerd
     **************************************************************************************/
    function setHumidAlertHandler(cb) {
        _humidAlertHandler = cb;
    }

    /***************************************************************************************
     * _lxThresholdHandler
     * Returns: null
     * Parameters:
     *      message : table - message received from bullwinkle listener
     *      reply: function that sends a reply to bullwinle message sender
     **************************************************************************************/
    function _lxThresholdHandler(message, reply) {
        if (_thresholdsUpdated) {
            reply(_lxThreshold);
            _thresholdsUpdated = false;
        } else {
            reply(null);
        }
    }

    /***************************************************************************************
     * _readingsHandler
     * Returns: null
     * Parameters:
     *      message : table - message received from bullwinkle listener
     *      reply: function that sends a reply to bullwinle message sender
     **************************************************************************************/
    function _readingsHandler(message, reply) {
        // grab readings array from message
        local readings = message.data;

        // set up variables for calculating reading average
        local tempAvg = 0;
        local humidAvg = 0
        local numReadings = 0;

        // set up variables for door event
        local doorOpen = null;
        local ts = null;

        // process readings
        // reading table keys : "brightness", "humidity", "temperature", "ts"
        foreach(reading in readings) {
            // calculate temperature and humidity totals
            if ("temperature" in reading && "humidity" in reading) {
                numReadings++;
                tempAvg += reading.temperature;
                humidAvg += reading.humidity;
            }

            // get time stamp of reading
            ts = reading.ts;

            // determine door status
            if ("brightness" in reading) doorOpen = _checkDoorEvent(ts, reading.brightness);
        }

        if (numReadings != 0) {
            // average the temperature and humidity readings
            tempAvg = tempAvg/numReadings;
            humidAvg = humidAvg/numReadings;

            // check for events
            _checkTempEvent(tempAvg, ts);
            _checkHumidEvent(humidAvg, ts);
        }

        // send reading to handler
        _streamReadingsHandler({"temperature" : tempAvg, "humidity" : humidAvg, "door" : doorOpen}, ts);
        // send ack to device (device erases this set of readings when ack received)
        reply("OK");
    }

    /***************************************************************************************
     * _checkTempEvent
     * Returns: null
     * Parameters:
     *      reading : float - a temperature reading
     **************************************************************************************/
    function _checkTempEvent(reading, ts) {
        // check for temp event
        if (reading > _tempThreshold) {
            // check that frig door hasn't been open recently & that alert hasn't been sent
            if (_doorOpenTS == null && !_tempAlertTriggered) {
                // create event timer
                if (_tempEventTime == null) {
                    _tempEventTime = ts + TEMP_ALERT_CONDITION;
                }
                // check that alert conditions have exceeded the time needed to trigger alert
                if (ts >= _tempEventTime) {
                    // Trigger Temp Alert
                    _tempAlertHandler(reading, ts, _tempThreshold);
                    // Set flag so we don't trigger the same alert again
                    _tempAlertTriggered = true;
                    // Reset Temp Event timer
                    _tempEventTime = null;
                }
            }
        } else {
            // Reset Temp Alert Conditions
            _tempAlertTriggered = false;
            _tempEventTime = null;
        }
    }

    /***************************************************************************************
     * _checkHumidEvent
     * Returns: null
     * Parameters:
     *      reading : float - a humidity reading
     **************************************************************************************/
    function _checkHumidEvent(reading, ts) {
        // check for humidity event
        if (reading > _humidThreshold) {
            // check that frig door hasn't been open recently & that alert hasn't been sent
            if (_doorOpenTS == null && !_humidAlertTriggered) {
                // create event timer
                if (_humidEventTime == null) {
                    _humidEventTime = ts + HUMID_ALERT_CONDITION;
                }
                // check that alert conditions have exceeded the time needed to trigger alert
                if ( ts >= _humidEventTime) {
                    // Trigger Humidity Alert
                    _humidAlertHandler(reading, ts, _humidThreshold);
                    // Set flag so we don't trigger the same alert again
                    _humidAlertTriggered = true;
                    // Reset Humidity timer
                    _humidEventTime = null;
                }
            }
        } else {
            // Reset Hmidity Alert Conditions
            _humidAlertTriggered = false;
            _humidEventTime = null;
        }
    }

    /***************************************************************************************
     * _checkDoorEvent
     * Returns: sting - door status
     * Parameters:
     *      lxLevel : float - a light reading
     *      readingTS : integer - the timestamp of the reading
     **************************************************************************************/
    function _checkDoorEvent(readingTS, lxLevel = null) {
        // Boolean if door open event occurred
        local doorOpen = (lxLevel == null || lxLevel > _lxThreshold);
        
        
        //fake it
        //doorOpen = true;
        // check if door open
        if (doorOpen) {
            _doorOpenCounter++;
            // check if door timer started
            if (!_doorOpenTS) {
                // start door timer
                _doorOpenTS = readingTS;
            // check that door alert conditions have been met
            } else if (!_doorOpenAlertTriggered && _doorOpenCounter > DOOR_OPEN_ALERT) {
                // trigger door open alert
                _doorOpenAlertTriggered = readingTS;
                _doorOpenHandler(readingTS - _doorOpenTS);
            }
        } else {
            // since door is closed, reset door open alert conditions
            _doorOpenCounter = 0;
            _doorOpenAlertTriggered = null;

            // check that door timer can be reset
            if (_doorOpenTS && (readingTS - _doorOpenTS) >= CLEAR_DOOR_OPEN_EVENT ) {
                // since door closed for set ammount of time, reset door event timer
                _doorOpenTS = null;
            }
        }
        return (doorOpen) ? "Open" : "Closed";
    }

}


// APPLICATION CLASS TO SEND FRIG DATA/ALERTS TO SALESFORCE
// ----------------------------------------------------------
class Application {

    _dm = null;
    _force = null;
    _deviceID = null;
    _objName = null;

    constructor(key, secret, objName) {
        _deviceID = imp.configparams.deviceid.tostring();
        _objName = objName;
        initializeClasses(key, secret);
        setDataMngrHandlers();
    }

    function initializeClasses(key, secret) {
        local _bull = Bullwinkle();

        _dm = SmartFrigDataManager(_bull);
        _force = SalesforceOAuth2(key, secret);
    }

    function setDataMngrHandlers() {
        _dm.setDoorOpenHandler(doorOpenHandler.bindenv(this));
        _dm.setStreamReadingsHandler(streamReadingsHandler.bindenv(this));
        _dm.setTempAlertHandler(tempAlertHandler.bindenv(this));
        _dm.setHumidAlertHandler(humidAlertHandler.bindenv(this));
    }

    function updateRecord(data, cb = null) {
        //local url = format("sobjects/%s/DeviceId__c/%s?_HttpMethod=PATCH", _objName, _deviceID);
        
        local url = format("sobjects/%s",_objName);
        local body = {};

        // add salesforce custom object postfix to data keys
        foreach(k, v in data) {
            body[k + "__c"] <- v;
        }
        
        // don't send if we are not logged in
        if (!_force.isLoggedIn()) {
            server.error("Not logged into saleforce.")
            return;
        }
        _force.request("POST", url, http.jsonencode(body), cb);
    }


    function openCase(subject, description, cb = null) {
        local data = {
            "Subject": subject,
            "Description": description,
            "Related_Fridge__r" : {"DeviceId__c": _deviceID}
        };

        // don't send if we are not logged in
        if (!_force.isLoggedIn()) {
            server.error("Not logged into saleforce.")
            return;
        }
        _force.request("POST", "sobjects/Case", http.jsonencode(data), cb);
    }

    function streamReadingsHandler(reading, ts) {
        reading.ts <- ts;
        server.log(http.jsonencode(reading));
        updateRecord(reading, updateRecordResHandler);
    }

    function doorOpenHandler(doorOpenFor) {
        local alert = "Refrigerator Door Open";
        local description = format("Refrigerator with id %s door has been open for %s seconds.", _deviceID, doorOpenFor.tostring());
        server.log("Door Open Alert: door has been open for " + doorOpenFor + " seconds.");
    //    openCase(alert, description, caseResponseHandler);
    }

    function tempAlertHandler(latestReading, alertTiggeredTime, threshold) {
        local alert = "Temperature Over Threshold";
        local description = format("Refrigerator with id %s temperature above %s °C. Refrigerator temperature is %s °C", _deviceID, threshold.tostring(), latestReading.tostring());
        server.log(alert + ": " + description);
    //    openCase(alert, description, caseResponseHandler);
    }

    function humidAlertHandler(latestReading, alertTiggeredTime, threshold) {
        local alert = "Humidity Over Threshold";
        local description = format("Refrigerator with id %s humidity above %s%s. Refrigerator humidity is %s%s", _deviceID, threshold.tostring(), "%", latestReading.tostring(), "%");
        server.log(alert + ": " + description);
    //    openCase(alert, description, caseResponseHandler);
    }

    function caseResponseHandler(err, data) {
        if (err) {
            server.error(http.jsonencode(err));
            return;
        }

        server.log("Created case with id: " + data.id);
    }

    function updateRecordResHandler(err, respData) {
        if (err) {
            server.error(http.jsonencode(err));
            return;
        }

        // Log a message for creating/updating a record
        if ("success" in respData) {
            server.log("Record created: " + respData.success);
        }
    }
}


// RUNTIME
// ---------------------------------------------------------------------------------

// SALESFORCE CONSTANTS
// ----------------------------------------------------------
//const CONSUMER_KEY = "3MVG9sG9Z3Q1RlbdgwDkzM3OQ0pucpBYYFHlKAiePxdYMpukQS6h5HZLXOr1UyJ8LN6eX2CHqpptOvPbro9C8";
//const CONSUMER_SECRET = "4373675996771098708";

//const CONSUMER_KEY = "3MVG9sG9Z3Q1RlbdgwDkzM3OQ0pCVPoENO6ckeLqNiiNEwnfivfT4sNlf34iLg_6zN28uYnYhSZ6xLesIMJIc";
//const CONSUMER_SECRET = "3331888167643794103";

const CONSUMER_KEY = "3MVG9SemV5D80oBcJQ6GPMXa9wIZr_GGASUCL67QrZOhmrq3hEgaQDlBNI27DrjF5RGja1.ltTEbiOAihrGh_";
const CONSUMER_SECRET = "9009196932862200945";

const OBJ_API_NAME = "Imp__e"

Application(CONSUMER_KEY, CONSUMER_SECRET, OBJ_API_NAME);

gistfile1.txt

// Temperature Humidity sensor Library
#require "Si702x.class.nut:1.0.0"
// Air Pressure sensor Library
#require "LPS25H.class.nut:2.0.1"
// Ambient Light sensor Library
#require "APDS9007.class.nut:2.2.1"

#require "ConnectionManager.class.nut:1.0.1"
#require "promise.class.nut:3.0.0"
#require "bullwinkle.class.nut:2.3.0"


/***************************************************************************************
 * EnvTail Class:
 *      Initializes and enables sensors specified in constructor
 *      Set time interval between readings
 *      Get time interval between readings
 *      Takes sensor readings & stores them to local device storage
 **************************************************************************************/
class EnvTail {
    _tempHumid = null;
    _ambLx = null;
    _press = null;
    _led = null;
    _cm = null;

    _readingInterval = null;

    /***************************************************************************************
     * Constructor
     * Returns: null
     * Parameters:
     *      enableTempHumid : boolean - if the temperature/humidity sensor should be enabled
     *      enableAmbLx : boolean - if the ambient light sensor should be enabled
     *      enablePressure : boolean - if the air pressure sensor should be enabled
     *      readingInt : second to wait between readings
     **************************************************************************************/
    constructor(enableTempHumid, enableAmbLx, enablePressure, readingInt, cm = null) {
        _cm = cm;
        _configureLED();
        _configureNVTable();
        _enableSensors(enableTempHumid, enableAmbLx, enablePressure);
        setReadingInterval(readingInt);
    }

    /***************************************************************************************
     * takeReadings - takes readings, sends to agent, schedules next reading
     * Returns: null
     * Parameters:
     *      cb (optional) : function - callback that is passed the parsed reading
     **************************************************************************************/
    function takeReadings(cb = null) {
        // Take readings asynchonously if sensor enabled
        local que = _buildReadingQue();

        // When all sensors have returned values store a reading locally
        // Then set timer for next reading
        Promise.all(que)
            .then(function(envReadings) {
                local reading = _parseReadings(envReadings);
                // store reading
                nv.readings.push(reading);
                // pass reading to callback
                if (cb) imp.wakeup(0, function() {
                    cb(reading);
                }.bindenv(this));
                // flash led to let user know a reading was stored
                flashLed();
            }.bindenv(this))
            .finally(function(val) {
                // set timer for next reading
                imp.wakeup(_readingInterval, function() {
                    takeReadings(cb);
                }.bindenv(this));
            }.bindenv(this));
    }

    /***************************************************************************************
     * setReadingInterval
     * Returns: this
     * Parameters:
     *      interval (optional) : the time in seconds to wait between readings,
     *                                     if nothing passed in sets the readingInterval to
     *                                     the default of 300s
     **************************************************************************************/
    function setReadingInterval(interval) {
        _readingInterval = interval;
        return this;
    }

    /***************************************************************************************
     * getReadingInterval
     * Returns: the current reading interval
     * Parameters: none
     **************************************************************************************/
    function getReadingInterval() {
        return _readingInterval;
    }

    /***************************************************************************************
     * flashLed - blinks the led, this function blocks for 0.5s
     * Returns: this
     * Parameters: none
     **************************************************************************************/
    function flashLed() {
        led.write(1);
        imp.sleep(0.5);
        led.write(0);
        return this;
    }

    // ------------------------- PRIVATE FUNCTIONS ------------------------------------------

    /***************************************************************************************
     * _configureNVTable
     * Returns: null
     * Parameters: none
     **************************************************************************************/
    function _configureNVTable() {
        local root = getroottable();
        if (!("nv" in root)) root.nv <- { "readings" : [] };
    }

    /***************************************************************************************
     * _buildReadingQue
     * Returns: an array of Promises for each sensor that is taking a reading
     * Parameters: none
     **************************************************************************************/
    function _buildReadingQue() {
        local que = [];
        if (_ambLx) que.push( _takeReading(_ambLx) );
        if (_tempHumid) que.push( _takeReading(_tempHumid) );
        if (_press) que.push( _takeReading(_press) );
        return que;
    }

    /***************************************************************************************
     * _takeReading
     * Returns: Promise that resolves with the sensor reading
     * Parameters:
     *      sensor: instance - the sensor to take a reading from
     **************************************************************************************/
    function _takeReading(sensor) {
        return Promise(function(resolve, reject) {
            sensor.read(function(reading) {
                return resolve(reading);
            }.bindenv(sensor));
        }.bindenv(this))
    }

    /***************************************************************************************
     * _parseReadings
     * Returns: a table of successful readings
     * Parameters:
     *      readings: array - with each sensor reading/error
     **************************************************************************************/
    function _parseReadings(readings) {
        // add time stamp to reading
        local data = {"ts" : time()};
        // log error or store value of reading
        foreach(reading in readings) {
            if ("err" in reading) {
                (_cm) ? _cm.error(reading.err) : server.error(reading.err);
            } else if ("error" in reading) {
                (_cm) ? _cm.error(reading.error) : server.error(reading.error);
            } else {
                foreach(sensor, value in reading) {
                    data[sensor] <- value;
                }
            }
        }
        return data;
    }

    /***************************************************************************************
     * _enableSensors
     * Returns: this
     * Parameters:
     *      tempHumid: boolean - if temperature/humidity sensor should be enabled
     *      ambLx: boolean - if ambient light sensor should be enabled
     *      press: boolean - if air pressure sensor should be enabled
     **************************************************************************************/
    function _enableSensors(tempHumid, ambLx, press) {
        if (tempHumid || press) _configure_i2cSensors(tempHumid, press);
        if (ambLx) _configureAmbLx();
        return this;
    }

    /***************************************************************************************
     * _configure_i2cSensors
     * Returns: this
     * Parameters:
     *      tempHumid: boolean - if temperature/humidity sensor should be enabled
     *      press: boolean - if air pressure sensor should be enabled
     **************************************************************************************/
    function _configure_i2cSensors(tempHumid, press) {
        local i2c = hardware.i2c89;
        i2c.configure(CLOCK_SPEED_400_KHZ);
        if (tempHumid) _tempHumid = Si702x(i2c);
        if (press) {
            _press = LPS25H(i2c);
            // set up to take readings
            _press.softReset();
            _press.enable(true);
        }
        return this;
    }

    /***************************************************************************************
     * _configureAmbLx
     * Returns: this
     * Parameters: none
     **************************************************************************************/
    function _configureAmbLx() {
        local lxOutPin = hardware.pin5;
        local lxEnPin = hardware.pin7;
        lxOutPin.configure(ANALOG_IN);
        lxEnPin.configure(DIGITAL_OUT, 1);

        _ambLx = APDS9007(lxOutPin, 47000, lxEnPin);
        _ambLx.enable();
        return this;
    }

    /***************************************************************************************
     * _configureLED
     * Returns: this
     * Parameters: none
     **************************************************************************************/
    function _configureLED() {
        _led = hardware.pin2;
        _led.configure(DIGITAL_OUT, 0);
        return this;
    }
}

/***************************************************************************************
 * Application Class:
 *      Starts off reading loop
 *      Sends readings to agent
 **************************************************************************************/
class Application {
    static DEFAULT_READING_INTERVAL = 3;
    static DEFAULT_REPORTING_INTERVAL = 15;
    static DEFAULT_LX_THRESHOLD = 50; // LX level indicating door open

    _bull = null;
    _cm = null;
    _tail = null;

    _readinInt = null;
    _reportingInt = null;
    _lxThreshold = null;
    _doorOpen = null;
    _reportingTimer = null;

    /***************************************************************************************
     * constructor
     * Returns: null
     * Parameters:
     *      readingInt : integer - time interval in seconds between readings
     *      reportingInt : integer - time interval in seconds between connections to agent
     **************************************************************************************/
    constructor(readingInt = null, reportingInt = null) {
        // configure class variables
        _readinInt = (readingInt == null) ? DEFAULT_READING_INTERVAL : readingInt;
        _reportingInt = (reportingInt == null) ? DEFAULT_REPORTING_INTERVAL : reportingInt;

        _initializeClasses();
        imp.wakeup(0.2, _getLXThreshold.bindenv(this));
    }


    /***************************************************************************************
     * run - starts reading loop, starts reporting loop
     * Returns: null
     * Parameters: none
     **************************************************************************************/
    function run() {
        // set doorOpen flag
        _doorOpen = false;

        // start reading loop
        _tail.takeReadings(checkForDoorEvent.bindenv(this));

        // send readings everytime we connect to server
        _cm.onConnect(sendReadings.bindenv(this));

        // wait one cycle then connect and send readings
        _reportingTimer = imp.wakeup(_reportingInt, _cm.connect.bindenv(_cm));
    }

    /***************************************************************************************
     * checkForDoorEvent
     * Returns: null
     * Parameters:
     *      reading : table of sensor readings
     **************************************************************************************/
    function checkForDoorEvent(reading) {
        // set default if no lighting threshold has been received from agent
        if (_lxThreshold == null) _lxThreshold = DEFAULT_LX_THRESHOLD;

        if ("brightness" in reading && reading.brightness > _lxThreshold) {
            // cancel the reporting timer
            imp.cancelwakeup(_reportingTimer);
            _doorOpen = true;
            // wake up now and send change in door status
            _cm.connect();
        } else if (_doorOpen) {
            // door was just closed
            // cancel the reporting timer
            imp.cancelwakeup(_reportingTimer);
            _doorOpen = false;
            // wake up now and send change in door status
            _cm.connect();
        }
    }

    /***************************************************************************************
     * sendReadings - send readings from local storage to agent
     *                then clear local storage & disconnect
     * Returns: null
     * Parameters: none
     **************************************************************************************/
    function sendReadings() {
        // check for readings
        if ("nv" in getroottable() && "readings" in nv) {
            // send readings to agent
            _bull.send("readings", nv.readings)
                // if agent receives readings
                // erase them from local storage then disonncet
                .onReply(function(msg) {
                    nv.readings = [];
                    _cm.disconnect();
                }.bindenv(this))
                // if connection fails just disconnect
                // readings will be kept and sent on next connection
                .onFail(function(err, msg, retry) {
                    _cm.disconnect();
                }.bindenv(this));
        } else {
            // if no readings are available disconnect
            _cm.disconnect();
        }

        // schedule next connection
        _reportingTimer = imp.wakeup(_reportingInt, _cm.connect.bindenv(_cm));
    }


    // ------------------------- PRIVATE FUNCTIONS ------------------------------------------

    /***************************************************************************************
     * _initializeClasses
     * Returns: null
     * Parameters: none
     **************************************************************************************/
    function _initializeClasses() {
        // agent/device communication helper library
        _bull = Bullwinkle();
        // connection helper library
        _cm = ConnectionManager({"blinkupBehavior" : ConnectionManager.BLINK_ALWAYS});
        // Class to manage sensors
        _tail = EnvTail(true, true, false, _readinInt, _cm);
    }


    /***************************************************************************************
     * _getLXThreshold
     * Returns: null
     * Parameters: none
     **************************************************************************************/
    function _getLXThreshold() {
        _bull.send("lxThreshold", null)
            .onReply(function(message) {
                if (message.data != null) {
                    _lxThreshold = message.data;
                }
            }.bindenv(this));
    }
}


// RUNTIME
// ----------------------------------------------

// Create instances of our classes
app <- Application();

// Give agent time to configure watson device
// Then start the sensor reading & connection loops
imp.wakeup(5, app.run.bindenv(app));