ecobee 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f15c138cad29178c3935acfdffc88446ca994d35
-  data.tar.gz: 58581cf67d84e8e0e43b83b2375069aa70d41a9b
+  metadata.gz: 4e2b2a04ef326e3e40a7e7c4191de520a5792d4d
+  data.tar.gz: 88ff1e1a5805e3a157b0c7b5ce093210d3ab8393
 SHA512:
-  metadata.gz: 6cb824a3793ecd6582479f00c94fad5d3819d4a7da373abdadbed6fdf7bb108a9072e7091780fb6f42842d60c648e827750a53e4a77c9455d3b59bc09faf325d
-  data.tar.gz: 5f8afab66b9bb155caf5b6f4691a72a8ada13765cfe64d3f83555bfcd910473d6f9d51115d87e81fbb8804593f90ed17d5f01c5ef0ecc04cd06c2d994358e9ed
+  metadata.gz: 5b902bc54d038513952d96a1e0b962a65b2748d8ff80447c700eb62ba6b793c15fb9bc907db76fff960ae656b08a4c3f3610699331fc5783f2902a37a9fe0a89
+  data.tar.gz: 445de99fe41e275297d56859752c232e940da0604e43ec13881d09a4d6ab3b3f0fc2b3f3ce9a91b4cebf044c470881f6847b66d26d33841575df17edd096c2cc

data/README.md

@@ -2,21 +2,23 @@
 
 Ecobee API Ruby Gem.  Implements: 
 - OAuth PIN-based token registration & renewal
-- Persistent HTTP connection
-- Methods for GET & POST requests
+- Persistent HTTP connection management
+- Methods for GET & POST requests w/ JSON parsing & error handling
 - Persistent storage for API key & refresh tokens
 - Example usage scripts (see /examples/\*)
 
-Status:
-- Working, but is very basic. Contact me with feature requests.
-
 TODO:
-- Document API
-- Convert token storage to optional block/proc
+- Move all HTTP interaction to a dedicated/shared class
+- Add and test more robust Status != 0 handling via Exceptions; document
+- Add retries for specific !0 statuses
+- Add random timeout padding to avoid race conditions with multiple clients when refreshing tokens
+- Add RDoc documentation
+- Add block/proc support to token storage routines
 - Add timeout to Ecobee::Token#wait
 - Add redirect based registration
-- Implement throttling / blocking
-- Helper methods/classes for building/reading requests
+- Implement throttling algorithm based on API feedback 
+- Create helper methods/classes with more abstraction
+- Create examples of proper error handling
 
 ## Installation
 

data/examples/set_mode.rb

@@ -5,8 +5,7 @@
 
 require 'pp'
 
-#require 'ecobee'
-require_relative '../lib/ecobee.rb'
+require_relative '../lib/ecobee'
 
 @hvac_modes = Ecobee::HVAC_MODES + ['quit']
 
@@ -16,17 +15,11 @@ class TestFunctions
   end
 
   def print_summary
-    response = @client.get(
-      'thermostat', 
-      { 
-        'selection' => {
-          'selectionType' => 'registered',
-          'selectionMatch' => '', 
-          'includeEquipmentStatus' => 'true',
-          'includeSettings' => 'true'
-        }
-      }
-    )
+    response = @client.get(:thermostat, 
+                           Ecobee::Selection(
+                             includeEquipmentStatus: true,
+                             includeSettings: true
+                           ))
 
     puts "Found %d thermostats." % response['thermostatList'].length
 
@@ -43,30 +36,22 @@ class TestFunctions
   end
 
   def update_mode(mode)
-    @client.post(
-      'thermostat', 
-      body: { 
-        'selection' => {
-          'selectionType' => 'registered',
-          'selectionMatch' => '',
-        },
-        'thermostat' => {
-          'settings' => {
-            'hvacMode' => mode
-          }
-        }
-      }
-    )
+    @client.post('thermostat',
+                 body: { 
+                   'thermostat' => {
+                     'settings' => { 'hvacMode' => mode }
+                   }
+                 }.merge(Ecobee::Selection()))
   end
 end
 
-token = Ecobee::Token.new(
-  app_key: ENV['ECOBEE_APP_KEY'],
-  app_name: 'ecobee-gem'
-)
+token = Ecobee::Token.new(app_key: ENV['ECOBEE_APP_KEY'])
+
+if token.pin
+  puts token.pin_message
+  token.wait 
+end
 
-puts token.pin_message if token.pin
-token.wait 
 test_functions = TestFunctions.new(
   Ecobee::Client.new(token: token)
 )

data/examples/test_save_hooks.rb

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+
+class TestSave
+  require 'pp'
+
+  def initialize
+    @callbacks = {}
+    Thread.new {
+      loop do
+        run_hooks
+        sleep 5
+      end
+    }
+  end   
+
+
+  def register(type, *callback, &block)
+    if block_given?
+      @callbacks[type] = block
+    else
+      @callbacks[type] = callback[0] if callback.length > 0
+    end
+  end
+
+  def run_hooks
+    if rand(2) == 0
+      puts "Running Load"
+      token_data_load
+    else
+      puts "Running Save"
+      token_data_save
+    end
+  end
+
+  def token_data_load
+    load_data = read_from_file if @save_files_enabled
+    if @callbacks[:load].respond_to? :call
+      load_data = @callbacks[:load].call(load_data)
+    end
+    process_load_data load_data if load_data
+  end
+
+  def token_data_save
+    save_data = get_save_data
+    if @callbacks[:save].respond_to? :call
+      save_data = @callbacks[:save].call(save_data)
+    end
+    write_to_file save_data if @save_files_enabled
+  end
+
+end
+
+# Load:
+# - Reads file
+# - callback filter
+# - Processes to memory
+#
+# Save:
+# - Processes from memory
+# - callback filter
+# - writes to file (read all file; overwrite only this section; write)
+
+# access_token
+# - is it expired?
+#  - No: use existing
+#  - Yes: re-load from file; doublecheck
+
+# refresh - only run if token is expired or via init if @refresh_token supplied (?)
+# - gets new token
+# - loads to memory
+# - runs save
+
+# config elements:
+# 
+# app_key 
+#
+# (@status = :ready)
+#   access_token
+#   access_token_expire
+#   refresh_token
+#   scope (read-only)
+#   token_type (read-only)
+# (@status = :authorization_pending)
+#   pin
+#   code
+#   code_expire
+
+config[:pin]
+config[:code]
+config[:code_expire]

data/examples/test_thermostat_object.rb

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require 'pp'
+require 'benchmark'
+
+require_relative '../lib/ecobee'
+
+token = Ecobee::Token.new(app_key: ENV['ECOBEE_APP_KEY'])
+if token.pin
+  puts token.pin_message 
+  token.wait 
+end
+
+thermostat = Ecobee::Thermostat.new(token: token)
+
+puts "Mode: " + thermostat[:settings][:hvacMode]
+
+#thermostat[:devices][0][:sensors].each do |sensor|
+#  puts "Sensor: #{sensor[:name]}"
+#end
+
+#puts thermostat.keys
+
+#thermostat[:program][:climates].each do |climate|
+#  puts "Climate: #{climate[:name]}"
+#end
+#

data/examples/test_token.rb

@@ -3,18 +3,33 @@
 # Refreshes token; displays details on saved token.  -- @robzr
 
 require 'pp'
-require_relative '../lib/ecobee.rb'
+
+require_relative '../lib/ecobee'
+
+load_lambda = lambda do |config|
+  config
+end
+
+save_lambda = lambda do |config|
+  config
+end
 
 token = Ecobee::Token.new(
   app_key: ENV['ECOBEE_APP_KEY'],
-  app_name: 'ecobee-gem'
+  callbacks: { 
+    load: load_lambda,
+    save: save_lambda
+  }
 )
 
 puts token.pin_message if token.pin
 token.wait
 
+token.config_save
+
+puts "APP Key: #{token.app_key}"
 puts "Access Token: #{token.access_token}"
 puts "Refresh Token: #{token.refresh_token}"
-puts "Expires At: #{token.access_expires_at}"
+puts "Expires At: #{token.access_token_expire}"
 puts "Scope: #{token.scope}"
-puts "Type: #{token.type}"
+puts "Type: #{token.token_type}"

data/lib/ecobee.rb

@@ -2,33 +2,65 @@ require 'pp'
 require 'json'
 require 'net/http'
 
-require 'ecobee/client'
-require 'ecobee/register'
-require 'ecobee/token'
-require 'ecobee/version'
-#require_relative 'ecobee/client'
-#require_relative 'ecobee/register'
-#require_relative 'ecobee/token'
-#require_relative 'ecobee/version'
+#require 'ecobee/client'
+#require 'ecobee/register'
+#require 'ecobee/token'
+#require 'ecobee/version'
+
+require_relative 'ecobee/client'
+require_relative 'ecobee/register'
+require_relative 'ecobee/thermostat'
+require_relative 'ecobee/token'
+require_relative 'ecobee/version'
 
 module Ecobee
   API_HOST = 'api.ecobee.com'
   API_PORT = 443
+
   CONTENT_TYPE = ['application/json', { 'charset' => 'UTF-8' }]
+
   DEFAULT_FILES = [
     '~/Library/Mobile Documents/com~apple~CloudDocs/.ecobee_token',
     '~/.ecobee_token'
   ]
-  HVAC_MODES = ['auto', 'auxHeatOnly', 'cool', 'heat', 'off']
-  REFRESH_INTERVAL_PAD = 120
+
+  AUTH_ERRORS = %w{
+    authorization_expired
+    authorization_pending 
+    invalid_client 
+    slow_down 
+  }
+
+  FAN_MODES = %w{auto on}
+
+  HVAC_MODES = %w{auto auxHeatOnly cool heat off}
+
+  REFRESH_PAD = 120
   REFRESH_TOKEN_CHECK = 10 
+
   SCOPES = [:smartWrite, :smartRead]
+
   URL_BASE= "https://#{API_HOST}:#{API_PORT}"
   URL_API = "#{URL_BASE}/1/"
   URL_GET_PIN = URL_BASE + 
     '/authorize?response_type=ecobeePin&client_id=%s&scope=%s'
   URL_TOKEN = "#{URL_BASE}/token"
 
+  def self.FanMode(mode)
+    { 'auto'        => 'Auto',
+      'on'          => 'On'
+    }.fetch(mode, 'Unknown')
+  end
+
+  def self.Mode(mode)
+    { 'auto'        => 'Auto',
+      'auxHeatOnly' => 'Aux Heat Only',
+      'cool'        => 'Cool',
+      'heat'        => 'Heat',
+      'off'         => 'Off'
+    }.fetch(mode, 'Unknown')
+  end
+
   def self.Model(model)
     { 'idtSmart'    => 'ecobee Smart',
       'idtEms'      => 'ecobee Smart EMS',
@@ -37,7 +69,7 @@ module Ecobee
       'athenaSmart' => 'ecobee3 Smart',
       'athenaEms'   => 'ecobee3 EMS',
       'corSmart'    => 'Carrier or Bryant Cor',
-    }[model] || 'Unknown'
+    }.fetch(model, "Unknown (#{model})")
   end
 
   def self.ResponseCode(code)
@@ -59,7 +91,7 @@ module Ecobee
       15 => 'Duplicate data violation.',
       16 => 'Invalid token. Token has been deauthorized by user. You must ' +
             're-request authorization.'
-    }[code] || 'Unknown Error.'
+    }.fetch(code.to_i, 'Unknown Error.')
   end
 
   def self.Selection(arg = {})

data/lib/ecobee/client.rb

@@ -8,27 +8,36 @@ module Ecobee
     end
 
     def get(arg, options = nil)
-      new_uri = URL_API + arg.sub(/^\//, '')
+      new_uri = URL_API + arg.to_s.sub(/^\//, '')
       new_uri += '?json=' + options.to_json if options
-
       request = Net::HTTP::Get.new(URI(URI.escape(new_uri)))
       request['Content-Type'] = *CONTENT_TYPE
       request['Authorization'] = @token.authorization
       http_response = http.request request
-      validate_status JSON.parse(http_response.body)
+      response = validate_status JSON.parse(http_response.body)
+#      if response == :retry
+#        get(arg, options)
+#      else
+#        response
+#      end
     rescue JSON::ParserError => msg
       raise ClientError.new("JSON::ParserError => #{msg}")
     end
 
     def post(arg, options: {}, body: nil)
-      new_uri = URL_API + arg.sub(/^\//, '')
+      new_uri = URL_API + arg.to_s.sub(/^\//, '')
       request = Net::HTTP::Post.new(URI new_uri)
       request.set_form_data({ 'format' => 'json' }.merge(options))
       request.body = JSON.generate(body) if body
       request['Content-Type'] = *CONTENT_TYPE
       request['Authorization'] = @token.authorization
       http_response = http.request request
-      validate_status JSON.parse http_response.body
+      response = validate_status JSON.parse http_response.body
+#      if response == :retry
+#        post(arg, options: options, body: body)
+#      else
+#        response
+#      end
     rescue JSON::ParserError => msg
       raise ClientError.new("JSON::ParserError => #{msg}")
     end
@@ -38,6 +47,8 @@ module Ecobee
         raise ClientError.new('Missing Status')
       elsif !response['status'].key? 'code'
         raise ClientError.new('Missing Status Code')
+      elsif response['status']['code'] == 14 
+        :retry
       elsif response['status']['code'] != 0
         raise ClientError.new(
           "GET Error: #{response['status']['code']} " +

data/lib/ecobee/register.rb

@@ -1,13 +1,11 @@
 module Ecobee
-  require 'date'
-
   class Register
     attr_reader :expires_at, :result
 
     def initialize(app_key: nil, scope: SCOPES[0])
       raise ArgumentError.new('Missing app_key') unless app_key
       @result = get_pin(app_key: app_key, scope: scope)
-      @expires_at = DateTime.now.strftime('%s').to_i + result['expires_in'] * 60
+      @expires_at = Time.now.to_i + result['expires_in'] * 60
     end
 
     def code
@@ -33,18 +31,20 @@ module Ecobee
       result = JSON.parse Net::HTTP.get(uri_pin)
       if result.key? 'error'
         raise Ecobee::TokenError.new(
-          "Register Error: (%s) %s" % [result['error'], result['error_description']]
+          sprintf("Register Error: (%s) %s",
+                  result['error'],
+                  result['error_description'])
         )
+      else
+        result
       end
-      result
     rescue SocketError => msg
       raise Ecobee::TokenError.new("GET failed: #{msg}")
     rescue JSON::ParserError => msg
       raise Ecobee::TokenError.new("Parse Error: #{msg}")
-    rescue Exception => msg
-      raise Ecobee::TokenError.new("Unknown Error: #{msg}")
+#    rescue Exception => msg
+#      raise Ecobee::TokenError.new("Unknown Error: #{msg}")
     end
 
   end
-
 end

data/lib/ecobee/thermostat.rb

@@ -0,0 +1,212 @@
+module Ecobee
+  class ThermostatError < StandardError ; end
+
+  class Thermostat < Hash
+
+    DEFAULT_SELECTION_ARGS = {
+      includeRuntime: true,
+      includeExtendedRuntime: true,
+      includeElectricity: true,
+      includeSettings: true,
+      includeLocation: true,
+      includeProgram: true,
+      includeEvents: true,
+      includeDevice: true,
+      includeTechnician: true,
+      includeUtility: true,
+      includeAlerts: true,
+      includeWeather: true,
+      includeOemConfig: true,
+      includeEquipmentStatus: true,
+      includeNotificationSettings: true,
+      includeVersion: true,
+      includeSensors: true
+    }
+
+    attr_accessor :client
+    attr_reader :auto_refresh, :orig_response
+
+    def initialize(
+      auto_refresh: 0,
+      client: nil,
+      fake_index: nil,
+      index: 0,
+      fake_max_index: 0,
+      selection: nil,
+      selection_args: {},
+      token: nil,
+      to_sym: true
+    )
+      @auto_refresh = auto_refresh
+      # TODO: add auto-refresh thread handling
+      @client = client || Ecobee::Client.new(token: token)
+      @to_sym = to_sym
+      @fake_index = fake_index
+      @fake_max_index = fake_max_index
+      @index = index
+      @selection ||= Ecobee::Selection(
+        DEFAULT_SELECTION_ARGS.merge(selection_args)
+      )
+      refresh
+    end
+
+    def cool_range(with_delta: false)
+      if with_delta
+        low_range = [@orig_response['settings']['coolRangeLow'] / 10,
+                     desired_heat + heat_cool_min_delta].max
+      else
+        low_range = @orig_response['settings']['coolRangeLow'] / 10
+      end
+      (low_range..@orig_response['settings']['coolRangeHigh'] / 10)
+    end
+
+    def heat_cool_min_delta
+      @orig_response['settings']['heatCoolMinDelta'] / 10
+    end
+
+    def desired_cool
+      @orig_response['runtime']['desiredCool'] / 10
+    end
+
+    def desired_cool=(temp)
+      set_hold(cool_hold_temp: temp.to_i * 10)
+    end
+
+    def desired_fan_mode
+      @orig_response['runtime']['desiredFanMode']
+    end
+
+    def desired_fan_mode=(fan)
+      set_hold(fan: fan)
+    end
+
+    def desired_heat
+      @orig_response['runtime']['desiredHeat'] / 10
+    end
+
+    def desired_heat=(temp)
+      set_hold(heat_hold_temp: temp.to_i * 10)
+    end
+
+    def desired_range
+      (desired_heat..desired_cool)
+    end
+
+    def heat_range(with_delta: false)
+      if with_delta
+        high_range = [@orig_response['settings']['heatRangeHigh'] / 10,
+                     desired_cool - heat_cool_min_delta].min
+      else
+        high_range = @orig_response['settings']['heatRangeHigh'] / 10
+      end
+      (@orig_response['settings']['heatRangeLow'] / 10..high_range)
+    end
+
+    def index
+      @fake_index || @index
+    end
+
+    def max_index
+      [@fake_index || 0, @max_index, @fake_max_index].max
+    end
+
+    def mode
+      @orig_response['settings']['hvacMode']
+    end
+
+    def mode=(mode)
+      set_mode(mode)
+    end
+
+    def model
+      Ecobee::Model(@orig_response['modelNumber'])
+    end
+
+    def my_selection
+      { 
+        'selection' => {
+          'selectionType' => 'thermostats',
+          'selectionMatch' => @orig_response['identifier']
+        }
+      }
+    end
+
+    def name
+      if @fake_index
+        "Fake No. #{@fake_index}"
+      else
+        @orig_response['name']
+      end
+    end
+
+    def refresh
+      response = @client.get(:thermostat, @selection)
+      if @index + 1 > response['thermostatList'].length
+        raise ThermostatError.new('No such thermostat')
+      end
+      @max_index = response['thermostatList'].length - 1
+      @orig_response = response['thermostatList'][@index]
+ 
+      self.replace(@to_sym ? to_sym(@orig_response) : @orig_response)
+    end 
+
+    def humidity
+      @orig_response['runtime']['actualHumidity']
+    end
+
+    def temperature
+      @orig_response['runtime']['actualTemperature'] / 10.0
+    end
+
+    def to_sym?
+      @to_sym
+    end
+
+    def to_sym(obj = self)
+      if obj.is_a? Hash
+        Hash[obj.map do |key, val|
+              if key.is_a? String
+                [key.to_sym, to_sym(val)]
+              else
+                [key, to_sym(val)]
+              end
+            end]
+      elsif obj.is_a? Array
+        obj.map { |item| to_sym(item) }
+      else
+        obj
+      end
+    end
+
+    def set_hold(
+      cool_hold_temp: @orig_response['runtime']['desiredCool'],
+      fan: nil,
+      heat_hold_temp: @orig_response['runtime']['desiredHeat'],
+      hold_type: 'nextTransition'
+    )
+      params = { 
+        'holdType' => 'nextTransition',
+        'coolHoldTemp' => cool_hold_temp,
+        'heatHoldTemp' => heat_hold_temp
+      }
+      params.merge!({ 'fan' => fan }) if fan
+
+      update(functions: [{ 'type' => 'setHold', 'params' => params }])
+    end
+
+    def set_mode(mode)
+      update(thermostat: { 'settings' => { 'hvacMode' => mode } })
+    end
+
+    def update(
+      functions: nil,
+      thermostat: nil
+    )
+      body = my_selection
+      body.merge!({ 'functions' => functions }) if functions
+      body.merge!({ 'thermostat' => thermostat }) if thermostat
+      @client.post(:thermostat, body: body)
+    end
+
+  end
+end

data/lib/ecobee/token.rb

@@ -1,63 +1,77 @@
 module Ecobee
-  require 'date' 
-
   class Token
-    attr_reader :access_expires_at, 
-                :access_token, 
+    attr_reader :access_token, 
+                :access_token_expire, 
+                :app_key,
+                :callbacks,
                 :pin,
-                :pin_message,
                 :refresh_token,
                 :result,
                 :status,
                 :scope,
-                :type
+                :token_type
+
+    #AUTH_ERRORS = %w(slow_down authorization_pending authorization_expired)
+    #VALID_STATUS = [:authorization_pending, :ready]
 
     def initialize(
-      access_expires_at: nil,
       access_token: nil,
+      access_token_expire: nil,
       app_key: nil,
-      app_name: nil,
-      code: nil,
+      callbacks: {},
       refresh_token: nil,
       scope: SCOPES[0],
       token_file: DEFAULT_FILES
     )
-      @access_expires_at = access_expires_at
       @access_token = access_token
+      @access_token_expire = access_token_expire
       @app_key = app_key
-      @app_name = app_name
-      @code = code
+      @callbacks = callbacks
       @refresh_token = refresh_token
       @scope = scope
       @token_file = expand_files token_file
 
-      @code_expires_at, @pin, @type = nil
-      parse_token_file
-      @status = @refresh_token ? :ready : :authorization_pending
+      @authorization_thread, @pin, @status, @token_type = nil
 
-      if @refresh_token
-        refresh
-      else
-        register unless pin_is_valid
-        check_for_token
-        launch_monitor_thread unless @status == :ready
-      end
+      @refresh_pad = REFRESH_PAD + rand(REFRESH_PAD)
+
+      config_load
+      access_token()
     end
 
     def access_token
-      refresh
-      @access_token
+      if(@access_token && @access_token_expire &&
+         Time.now.to_i + @refresh_pad < @access_token_expire)
+        @status = :ready
+        @access_token
+      else
+        refresh_access_token
+      end
     end
 
     def authorization
-      "#{@type} #{@access_token}"
+      "#{@token_type} #{access_token}"
+    end
+
+    def config_load
+      config = config_read_our_section
+      if @callbacks[:load].respond_to? :call
+        config = @callbacks[:load].call(config)
+      end
+      config_load_to_memory config
+    end
+
+    def config_save
+      config = config_dump()
+      if @callbacks[:save].respond_to? :call
+        config = @callbacks[:save].call(config)
+      end
+      config_write_section config
     end
 
     def pin_is_valid
-      if @pin && @code && @code_expires_at
-        @code_expires_at.to_i >= DateTime.now.strftime('%s').to_i
-      else
-        false
+      if @pin && @access_token && @access_token_expire
+        @access_token_expire.to_i >= Time.now.to_i
       end
     end
 
@@ -66,37 +80,51 @@ module Ecobee
       "enter the PIN #{@pin || ''}"
     end
 
-    def refresh
-      return if Time.now.to_i + REFRESH_INTERVAL_PAD < @access_expires_at
+    def refresh_access_token
       response = Net::HTTP.post_form(
         URI(URL_TOKEN),
         'grant_type' => 'refresh_token',
-        'refresh_token' => @refresh_token,
+        'refresh_token' => @refresh_token || 0,
         'client_id' => @app_key
       )
       result = JSON.parse(response.body)
       if result.key? 'error'
-        pp result
-        raise Ecobee::TokenError.new(
-          "Result Error: (%s) %s" % [result['error'],
-                                     result['error_description']]
-        )
+        if result['error'] == 'invalid_grant'
+          @status = :authorization_pending
+          check_for_authorization
+        else
+          puts "DUMPING(result): #{result.pretty_inspect}"
+          raise Ecobee::TokenError.new(
+            "Result Error: (%s) %s" % [result['error'],
+                                       result['error_description']]
+          )
+        end
       else
         @access_token = result['access_token']
-        @access_expires_at = Time.now.to_i + result['expires_in']
+        @access_token_expire = Time.now.to_i + result['expires_in']
+        @pin = nil
         @refresh_token = result['refresh_token']
-        @pin, @code, @code_expires_at = nil
         @scope = result['scope']
-        @type = result['token_type']
+        @token_type = result['token_type']
         @status = :ready
-        write_token_file
-      end
+        config_save
+        @access_token
+      end 
     rescue SocketError => msg
       raise Ecobee::TokenError.new("POST failed: #{msg}")
     rescue JSON::ParserError => msg
       raise Ecobee::TokenError.new("Result parsing: #{msg}")
-    rescue Exception => msg
-      raise Ecobee::TokenError.new("Unknown Error: #{msg}")
+#    rescue Exception => msg
+#      raise Ecobee::TokenError.new("Unknown Error: #{msg}")
+    end
+
+    def register_callback(type, *callback, &block)
+      if block_given?
+        puts "Registering #{type}"
+        @callbacks[type] = block
+      else
+        @callbacks[type] = callback[0] if callback.length > 0
+      end
     end
 
     def wait
@@ -106,16 +134,36 @@ module Ecobee
 
     private
 
-    def check_for_token
+    def check_for_authorization
+      check_for_authorization_single
+      if @status == :authorization_pending
+        unless @authorization_thread && @authorization_thread.alive?
+          @authorization_thread = Thread.new {
+            loop do
+              # TODO: consider some intelligent throttling
+              sleep REFRESH_TOKEN_CHECK
+              break if @status == :ready
+              check_for_authorization_single
+            end
+          }
+        end
+      end
+    end
+
+    def check_for_authorization_single
       response = Net::HTTP.post_form(
         URI(URL_TOKEN),
         'grant_type' => 'ecobeePin',
-        'code' => @code,
+        'code' => @access_token,
         'client_id' => @app_key
       )
       result = JSON.parse(response.body)
       if result.key? 'error'
-        unless ['slow_down', 'authorization_pending'].include? result['error']
+        @status = :authorization_pending
+
+        if result['error'] == 'invalid_client'
+          register 
+        elsif !['slow_down', 'authorization_pending'].include? result['error']
           # TODO: throttle or just ignore...?
           pp result
           raise Ecobee::TokenError.new(
@@ -126,59 +174,67 @@ module Ecobee
       else
         @status = :ready
         @access_token = result['access_token']
-        @type = result['token_type']
-        @access_expires_at = Time.now.to_i + result['expires_in']
+        @token_type = result['token_type']
+        @access_token_expire = Time.now.to_i + result['expires_in']
         @refresh_token = result['refresh_token']
         @scope = result['scope']
-        @pin, @code, @code_expires_at = nil
-        write_token_file
+        @pin = nil
+        config_save
+        @access_token
       end
     rescue SocketError => msg
       raise Ecobee::TokenError.new("POST failed: #{msg}")
     rescue JSON::ParserError => msg
       raise Ecobee::TokenError.new("Result parsing: #{msg}")
-    rescue Exception => msg
-      raise Ecobee::TokenError.new("Unknown Error: #{msg}")
+#    rescue Exception => msg
+#      raise Ecobee::TokenError.new("Unknown Error: #{msg}")
     end
 
-    def expand_files(token_file)
-      if token_file.is_a? Array
-        token_file.map { |tf| File.expand_path tf }
-      else
-        expand_files [token_file]
-      end
-    end
-
-    def launch_monitor_thread
-      Thread.new {
-        loop do
-          sleep REFRESH_TOKEN_CHECK
-          break if @status == :ready
-          check_for_token 
+    def config_load_to_memory(config)
+      @app_key ||= config['app_key']
+      if !@access_token
+        @access_token = config['access_token']
+        @access_token_expire = config['access_token_expire'].to_i
+      elsif(config.key?('access_token') && 
+            config['access_token_expire'].to_i > @access_token_expire)
+        @access_token = config['access_token']
+        @access_token_expire = config['access_token_expire'].to_i
+        if config['refresh_token']
+          @refresh_token = config['refresh_token'] 
+          @scope = config['scope']
+          @token_type = config['token_type']
+        elsif config.key?('pin')
+          @pin = config['pin']
         end
-      }
-    end
-
-    def parse_token_file
-      return unless (all_config = read_token_file).is_a? Hash
-      section = (@app_name && all_config.key?(@app_name)) ? @app_name : @app_key
-      return unless all_config.key?(section)
-      config = all_config[section]
-      @app_key ||= config.key?('app_key') ? config['app_key'] : @app_name
+      end
       if config.key?('refresh_token')
-        @access_expires_at ||= config['access_expires_at'].to_i
-        @access_token ||= config['access_token']
         @refresh_token ||= config['refresh_token']
         @scope ||= config['scope']
-        @type ||= config['token_type']
+        @token_type ||= config['token_type']
       elsif config.key?('pin')
-        @code ||= config['code']
-        @code_expires_at ||= config['code_expires_at'].to_i
         @pin ||= config['pin']
       end
     end
 
-    def read_json_file(file)
+    def config_read_our_section
+      all_config = config_read_all_sections
+      if @app_name && all_config.key?(@app_name)
+        our_section = @app_name
+      else
+        our_section = @app_key
+      end
+      return all_config[our_section] || {}
+    end
+
+    def config_read_all_sections
+      @token_file.each do |tf|
+         result = config_read_file(tf)
+         return result if result.length > 0
+      end
+      {}
+    end
+
+    def config_read_file(file)
       JSON.parse(
         File.open(file, 'r').read(16 * 1024)
       )
@@ -188,56 +244,62 @@ module Ecobee
       {}
     end
 
-    def read_token_file
-      @token_file.each do |tf|
-         result = read_json_file(tf)
-         return result if result.length > 0
+    def config_dump
+      config = {}
+      config['access_token'] = @access_token
+      config['access_token_expire'] = @access_token_expire
+      if @refresh_token
+        config['refresh_token'] = @refresh_token 
+        config['scope'] = @scope
+        config['token_type'] = @token_type
+      elsif @pin
+        config['pin'] = @pin
       end
+      config
     end
 
-    def register
-      result = Register.new(app_key: @app_key, scope: @scope)
-      @pin = result.pin
-      @code = result.code
-      @code_expires_at = result.expires_at
-      @scope = result.scope
-      write_token_file
-      result
-    end
+    def config_write_section(config)
+      all_config = config_read_all_sections
+      all_config.delete(@app_key)
+      all_config[@app_key] = config
 
-    def write_token_file
-      @token_file.each do |file|
-        return if write_json_file file
+      @token_file.each do |file_name|
+        return true if config_write_file(config: all_config, file_name: file_name)
       end
+      nil
     end
 
-    def write_json_file(file)
-      if config = read_token_file
-        config.delete(@app_name)
-        config.delete(@app_key)
-      end
-      section = @app_name || @app_key
-      config[section] = {}
-      config[section]['app_key'] = @app_key if @app_key && section != @app_key
-      if @refresh_token
-        config[section]['access_token'] = @access_token 
-        config[section]['access_expires_at'] = @access_expires_at
-        config[section]['refresh_token'] = @refresh_token 
-        config[section]['token_type'] = @type
-        config[section]['scope'] = @scope
-      elsif @pin
-        config[section]['pin'] = @pin
-        config[section]['code'] = @code
-        config[section]['code_expires_at'] = @code_expires_at
-      end
-      File.open(file, 'w') do |tf|
-        tf.puts JSON.pretty_generate(config)
+    def config_write_file(config: nil, file_name: nil)
+      File.open(file_name, 'w') do |file|
+        file.puts JSON.pretty_generate(config)
       end
       true
     rescue Errno::ENOENT
       nil
     end
 
+    def expand_files(token_file)
+      if token_file.is_a? NilClass
+        nil
+      elsif token_file.is_a? Array
+        token_file.map { |tf| File.expand_path tf }
+      else
+        expand_files [token_file]
+      end
+    end
+
+    def register
+      @status = :authorization_pending
+      result = Register.new(app_key: @app_key, scope: @scope)
+      @pin = result.pin
+      @access_token = result.code
+      @access_token_expire = result.expires_at
+      @scope = result.scope
+      check_for_authorization
+      config_save
+      @access_token if @status == :ready
+    end
+
   end
 
   class TokenError < StandardError

data/lib/ecobee/version.rb

@@ -1,3 +1,3 @@
 module Ecobee
-  VERSION = "0.2.0"
+  VERSION = "0.2.1"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ecobee
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Rob Zwissler
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-08-09 00:00:00.000000000 Z
+date: 2016-08-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -71,10 +71,13 @@ files:
 - bin/setup
 - ecobee.gemspec
 - examples/set_mode.rb
+- examples/test_save_hooks.rb
+- examples/test_thermostat_object.rb
 - examples/test_token.rb
 - lib/ecobee.rb
 - lib/ecobee/client.rb
 - lib/ecobee/register.rb
+- lib/ecobee/thermostat.rb
 - lib/ecobee/token.rb
 - lib/ecobee/version.rb
 homepage: https://github.com/robzr/ecobee
@@ -97,8 +100,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.0.14.1
 signing_key: 
 specification_version: 4
 summary: Ecobee API - token registration, persistent HTTP GET/PUSH
 test_files: []
+has_rdoc: