nest_connect 0.1.1

data/lib/nest_connect/chunk_parser.rb

@@ -0,0 +1,66 @@
+module NestConnect
+  class ChunkParser
+    EVENT = -'event: '
+    DATA = -'data: '
+
+    def self.write(chunk)
+      unless chunk.empty?
+        new(chunk)
+      end
+    end
+
+    def initialize(chunk)
+      @raw_event_line, @raw_data_line = chunk.split("\n")
+    end
+
+    def event
+      event_line
+    end
+
+    def data
+      JSON.parse(data_line, symbolize_names: true) || {}
+    end
+
+    def thermostats
+      Device::Thermostat.from_hash_collection(thermostats_hash)
+    end
+
+    def protects
+      Device::Protect.from_hash_collection(smoke_co_alarms_hash)
+    end
+
+    def cameras
+      Device::Camera.from_hash_collection(cameras_hash)
+    end
+
+    private
+
+      def data_hash
+        data.fetch(:data, {})
+      end
+
+      def devices_hash
+        data_hash.fetch(:devices, {})
+      end
+
+      def thermostats_hash
+        devices_hash.fetch(:thermostats, {})
+      end
+
+      def smoke_co_alarms_hash
+        devices_hash.fetch(:smoke_co_alarms, {})
+      end
+
+      def cameras_hash
+        devices_hash.fetch(:cameras, {})
+      end
+
+      def data_line
+        @raw_data_line.gsub(DATA, "")
+      end
+
+      def event_line
+        @raw_event_line.gsub(EVENT, "")
+      end
+  end
+end

data/lib/nest_connect/config_store.rb

@@ -0,0 +1,53 @@
+require 'yaml'
+
+module NestConnect
+  class ConfigStore
+    def initialize(path)
+      @path = path
+    end
+
+    def [](key)
+      data[key]
+    end
+
+    def save(key, value)
+      data[key] = value
+
+      find_or_create_directory
+      find_or_create_file
+      persist_data
+
+      value
+    end
+
+    private
+
+      attr_reader :path
+
+      def find_or_create_directory
+        Dir.mkdir(pathname.dirname) unless Dir.exist?(pathname.dirname)
+      end
+
+      def find_or_create_file
+        File.new(path, "w") unless File.exists?(path)
+      end
+
+      def persist_data
+        File.open(path, "w") { |f| f.write(data.to_yaml) }
+      end
+
+      def pathname
+        Pathname.new(path)
+      end
+
+      def data
+        @_data ||= load_data
+      end
+
+      def load_data
+        YAML.load(File.read(path)) || {}
+      rescue
+        {}
+      end
+  end
+end

data/lib/nest_connect/devices/camera.rb

@@ -0,0 +1,60 @@
+module NestConnect
+  class Device
+    class Camera
+      def self.from_hash_collection(hash)
+        hash.values.map { |value| new(value) }
+      end
+
+      def initialize(api_class: NestConnect::API::Devices::Camera, **args)
+        @api_class = api_class
+        args.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
+
+      def reload
+        api_runner.get.body.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
+
+      attr_reader(
+        :device_id,
+        :software_version,
+        :structure_id,
+        :where_id,
+        :where_name,
+        :name,
+        :name_long,
+        :is_online,
+        :is_audio_input_enabled,
+        :last_is_online_change,
+        :is_video_history_enabled,
+        :web_url,
+        :app_url,
+        :is_public_share_enabled,
+        :activity_zones,
+        :public_share_url,
+        :snapshot_url,
+        :last_event
+      )
+
+      attr_reader :is_streaming
+
+      def is_streaming=(value)
+        normalized_value = !!value
+
+        api_runner.put({is_streaming: normalized_value})
+        @is_streaming = normalized_value
+      end
+
+      private
+
+        attr_reader :api_class
+
+        def api_runner
+          api_class.new(device_id)
+        end
+    end
+  end
+end

data/lib/nest_connect/devices/protect.rb

@@ -0,0 +1,49 @@
+module NestConnect
+  class Device
+    class Protect
+      def self.from_hash_collection(hash)
+        hash.values.map { |value| new(value) }
+      end
+
+      def initialize(api_class: NestConnect::API::Devices::Protect, **args)
+        @api_class = api_class
+        args.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
+
+      def reload
+        api_runner.get.body.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
+
+      attr_reader(
+        :battery_health,
+        :co_alarm_state,
+        :device_id,
+        :is_manual_test_active,
+        :is_online,
+        :last_connection,
+        :last_manual_test_time,
+        :locale,
+        :name,
+        :name_long,
+        :smoke_alarm_state,
+        :software_version,
+        :structure_id,
+        :ui_color_state,
+        :where_id,
+        :where_name
+      )
+
+      private
+
+        attr_reader :api_class
+
+        def api_runner
+          api_class.new(device_id)
+        end
+    end
+  end
+end

data/lib/nest_connect/devices/structure.rb

@@ -0,0 +1,85 @@
+module NestConnect
+  class Device
+    class Structure
+      def self.from_hash_collection(hash)
+        hash.values.map { |value| new(value) }
+      end
+
+      def initialize(api_class: NestConnect::API::Devices::Structure, **args)
+        @api_class = api_class
+        args.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
+
+      def reload
+        api_runner.get.body.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
+
+      attr_reader(
+        :co_alarm_state,
+        :country_code,
+        :eta_begin,
+        :peak_period_end_time,
+        :peak_period_start_time,
+        :postal_code,
+        :rhr_enrollment,
+        :smoke_alarm_state,
+        :structure_id,
+        :time_zone,
+        :wheres,
+        :wwn_security_state
+      )
+
+      def thermostats
+        @thermostats.to_a.map do |device_id|
+          Device::Thermostat.new(device_id: device_id)
+        end
+      end
+
+      def protects
+        @smoke_alarm_state.to_a.map do |device_id|
+          Device::Protect.new(device_id: device_id)
+        end
+      end
+
+      def cameras
+        @cameras.to_a.map do |device_id|
+          Device::Camera.new(device_id: device_id)
+        end
+      end
+
+      AWAY_VALUES = ['home', 'away']
+
+      attr_reader :away
+
+      def away=(value)
+        unless AWAY_VALUES.include?(value)
+          raise ValueError.new("away must be #{AWAY_VALUES}")
+        end
+
+        api_runner.put({away: value})
+        @away = value
+      end
+
+      attr_reader :name
+
+      def name=(value)
+        normalized_value = value.to_s
+
+        api_runner.put({name: normalized_value})
+        @name = normalized_value
+      end
+
+      private
+
+        attr_reader :api_class
+
+        def api_runner
+          api_class.new(structure_id)
+        end
+    end
+  end
+end

data/lib/nest_connect/devices/thermostat.rb

@@ -0,0 +1,194 @@
+module NestConnect
+  class RangeError < StandardError; end
+  class ValueError < StandardError; end
+
+  class Device
+    class Thermostat
+      def self.from_hash_collection(hash)
+        hash.values.map { |value| new(value) }
+      end
+
+      def initialize(api_class: NestConnect::API::Devices::Thermostat, **args)
+        @api_class = api_class
+        args.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
+
+      def reload
+        api_runner.get.body.each do |key, value|
+          instance_variable_set("@#{key}", value)
+        end
+      end
+
+      TARGET_TEMPERATURE_F_RANGE = (50..90)
+
+      attr_reader :target_temperature_f
+
+      def target_temperature_f=(value)
+        normalized_value = value.round
+
+        unless TARGET_TEMPERATURE_F_RANGE.include?(normalized_value)
+          raise RangeError.new("target_temperature_f must be between #{TARGET_TEMPERATURE_F_RANGE}")
+        end
+
+        api_runner.put({target_temperature_f: normalized_value})
+        @target_temperature_f = normalized_value
+      end
+
+      TARGET_TEMPERATURE_C_RANGE = (9..30)
+
+      attr_reader :target_temperature_c
+
+      def target_temperature_c=(value)
+        normalized_value = (value * 2).round / 2.0
+
+        unless TARGET_TEMPERATURE_C_RANGE.include?(normalized_value)
+          raise RangeError.new("target_temperature_c must be between #{TARGET_TEMPERATURE_C_RANGE}")
+        end
+
+        api_runner.put({target_temperature_c: normalized_value})
+        @target_temperature_c = normalized_value
+      end
+
+      attr_reader :fan_timer_active
+
+      def fan_timer_active=(value)
+        normalized_value = !!value
+
+        api_runner.put({fan_timer_active: normalized_value})
+        @fan_timer_active = normalized_value
+      end
+
+      FAN_TIMER_DURATION_VALUES = [15, 30, 45, 60, 120, 240, 480, 720]
+
+      attr_reader :fan_timer_duration
+
+      def fan_timer_duration=(value)
+        unless FAN_TIMER_DURATION_VALUES.include?(value)
+          raise ValueError.new("fan_timer_duration must be #{FAN_TIMER_DURATION_VALUES}")
+        end
+
+        api_runner.put({fan_timer_duration: value})
+        @fan_timer_duration = value
+      end
+
+      HVAC_MODE_VALUES = ['heat', 'cool', 'heat-cool', 'eco', 'off']
+
+      attr_reader :hvac_mode
+
+      def hvac_mode=(value)
+        unless HVAC_MODE_VALUES.include?(value)
+          raise ValueError.new("hvac_mode must be #{HVAC_MODE_VALUES}")
+        end
+
+        api_runner.put({hvac_mode: value})
+        @hvac_mode = value
+      end
+
+      attr_reader :label
+
+      def label=(value)
+        normalized_value = value.to_s
+
+        api_runner.put({label: normalized_value})
+        @label = normalized_value
+      end
+
+      attr_reader :target_temperature_high_c
+
+      def target_temperature_high_c=(value)
+        normalized_value = (value * 2).round / 2.0
+
+        api_runner.put({target_temperature_high_c: normalized_value})
+        @target_temperature_high_c = normalized_value
+      end
+
+      attr_reader :target_temperature_low_c
+
+      def target_temperature_low_c=(value)
+        normalized_value = (value * 2).round / 2.0
+
+        api_runner.put({target_temperature_low_c: normalized_value})
+        @target_temperature_low_c = normalized_value
+      end
+
+      attr_reader :target_temperature_high_f
+
+      def target_temperature_high_f=(value)
+        normalized_value = value.round
+
+        api_runner.put({target_temperature_high_f: normalized_value})
+        @target_temperature_high_f = normalized_value
+      end
+
+      attr_reader :target_temperature_low_f
+
+      def target_temperature_low_f=(value)
+        normalized_value = value.round
+
+        api_runner.put({target_temperature_low_f: normalized_value})
+        @target_temperature_low_f = normalized_value
+      end
+
+      TEMPERATURE_SCALE_VALUES = ['C', 'F']
+
+      attr_reader :temperature_scale
+
+      def temperature_scale=(value)
+        unless TEMPERATURE_SCALE_VALUES.include?(value)
+          raise ValueError.new("temperature_scale must be #{TEMPERATURE_SCALE_VALUES}")
+        end
+
+        api_runner.put({temperature_scale: value})
+        @temperature_scale = value
+      end
+
+      attr_reader(
+        :ambient_temperature_c,
+        :ambient_temperature_f,
+        :can_cool,
+        :can_heat,
+        :device_id,
+        :eco_temperature_high_c,
+        :eco_temperature_high_f,
+        :eco_temperature_low_c,
+        :eco_temperature_low_f,
+        :fan_timer_duration,
+        :fan_timer_timeout,
+        :has_fan,
+        :has_leaf,
+        :humidity,
+        :hvac_state,
+        :is_locked,
+        :is_online,
+        :is_using_emergency_heat,
+        :last_connection,
+        :locale,
+        :locked_temp_max_c,
+        :locked_temp_max_f,
+        :locked_temp_min_c,
+        :locked_temp_min_f,
+        :name,
+        :name_long,
+        :previous_hvac_mode,
+        :software_version,
+        :structure_id,
+        :sunlight_correction_active,
+        :sunlight_correction_enabled,
+        :time_to_target,
+        :time_to_target_training,
+        :where_id,
+        :where_name
+      )
+
+      private
+
+        attr_reader :api_class
+
+        def api_runner
+          api_class.new(device_id)
+        end
+    end
+  end
+end

data/lib/nest_connect/global_config.rb

@@ -0,0 +1,37 @@
+module NestConnect
+  class GlobalConfig
+    DEFAULT_PATH = ENV["HOME"] + '/.nest_connect/config'
+
+    unless defined? @@path
+      @@path = nil
+    end
+
+    def self.path=(new_path)
+      @@path = new_path
+    end
+
+    def self.path
+      @@path || DEFAULT_PATH
+    end
+
+    def initialize(store = nil)
+      @store = store || ConfigStore.new(self.class.path)
+    end
+
+    def access_token
+      @_access_token ||= store[:access_token] || configure_access_token
+    end
+
+    def access_token=(token)
+      store.save(:access_token, token)
+    end
+
+    private
+
+      attr_reader :store
+
+      def configure_access_token
+        raise 'please configure your access token first by running nest_connect authorize'
+      end
+  end
+end

data/lib/nest_connect/version.rb

@@ -0,0 +1,3 @@
+module NestConnect
+  VERSION = "0.1.1"
+end

data/lib/nest_connect.rb

@@ -0,0 +1,14 @@
+require 'json'
+
+module NestConnect
+end
+
+require 'nest_connect/version'
+require 'nest_connect/global_config'
+require 'nest_connect/config_store'
+require 'nest_connect/api/api'
+require 'nest_connect/chunk_parser'
+require 'nest_connect/devices/camera'
+require 'nest_connect/devices/protect'
+require 'nest_connect/devices/structure'
+require 'nest_connect/devices/thermostat'

data/nest_connect.gemspec

@@ -0,0 +1,33 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "nest_connect/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "nest_connect"
+  spec.version       = NestConnect::VERSION
+  spec.authors       = ["Karl Entwistle"]
+  spec.email         = ["karl@entwistle.com"]
+
+  spec.summary       = %q{Simple API Wrapper for Nest Thermostats}
+  spec.homepage      = "https://github.com/karlentwistle/nest_connect"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'faraday', '~> 0.15'
+  spec.add_dependency 'faraday_middleware', '~> 0.12'
+  spec.add_dependency 'thor', '~> 0.20'
+
+  spec.add_development_dependency "bundler", "~> 1.17"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "webmock"
+end