alexa_hue 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b9fe3c650ed88c2c5cf706a1877915c87b97ecc1
+  data.tar.gz: 48b1157a1a2a04ab60b4f2c45fbda7621e873098
+SHA512:
+  metadata.gz: e77f71eb3efe6ecd76f1d2caaff0c90a3a76f43489ed9c6b19b0b8a6ec7d6ba38b2a7c84b4e17bf4b1c2c6cb6b29929368b99ea56c50bb791d93e1b37c9cb63f
+  data.tar.gz: b90184d7747efcfce1f23f72d37d7749783609eb303ce93345e7528770437e6eb8edc0c439c8840580cf96399115e5fb8cf00244ecdad74129cbf684792cf57b

data/.gitignore

@@ -0,0 +1,139 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+# Created by https://www.gitignore.io
+
+### RubyMine ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm
+
+*.iml
+
+## Directory-based project format:
+.idea/
+# if you remove the above rule, at least ignore the following:
+
+# User-specific stuff:
+# .idea/workspace.xml
+# .idea/tasks.xml
+# .idea/dictionaries
+
+# Sensitive or high-churn files:
+# .idea/dataSources.ids
+# .idea/dataSources.xml
+# .idea/sqlDataSources.xml
+# .idea/dynamic.xml
+# .idea/uiDesigner.xml
+
+# Gradle:
+# .idea/gradle.xml
+# .idea/libraries
+
+# Mongo Explorer plugin:
+# .idea/mongoSettings.xml
+
+## File-based project format:
+*.ipr
+*.iws
+
+## Plugin-specific files:
+
+# IntelliJ
+/out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+
+
+### SublimeText ###
+# cache files for sublime text
+*.tmlanguage.cache
+*.tmPreferences.cache
+*.stTheme.cache
+
+# workspace files are user-specific
+*.sublime-workspace
+
+# project files should be checked into the repository, unless a significant
+# proportion of contributors will probably not be using SublimeText
+# *.sublime-project
+
+# sftp configuration file
+sftp-config.json
+
+
+### Vim ###
+[._]*.s[a-w][a-z]
+[._]s[a-w][a-z]
+*.un~
+Session.vim
+.netrwhist
+*~
+
+
+### Ruby ###
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+# Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+.idea
+
+Gemfile.lock

data/Gemfile

@@ -0,0 +1,20 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'chronic', '~> 0.10.0'
+gem 'chronic_duration', '~> 0'
+gem 'httparty', '~> 0.13.0'
+gem 'numbers_in_words', '~> 0.2.0'
+gem 'sinatra'
+gem 'alexa_objects'
+gem 'activesupport'
+
+group :development do
+  gem "guard", "2.12.5", require: false
+  gem "guard-rspec", '4.5.0', require: false
+  gem "guard-bundler", require: false
+  gem "guard-rake", require: false
+  gem "terminal-notifier-guard", require: false
+  gem 'guard-yard', require: false
+end

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/alexa_hue.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'alexa_hue/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "alexa_hue"
+  spec.version       = Sinatra::Hue::VERSION
+  spec.authors       = ["Kyle Lucas"]
+  spec.email         = ["kglucas93@gmail.com"]
+  spec.summary       = %q{A sinatra middleware for alexa hue actions.}
+  spec.description   = %q{}
+  spec.homepage      = "http://github.com/kylegrantlucas/alexa_hue"
+  spec.license       = "MIT"
+  spec.required_ruby_version = '>= 1.9.3'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib", 'skills_config']
+
+  spec.add_runtime_dependency 'json'
+  spec.add_runtime_dependency 'alexa_objects'
+  spec.add_runtime_dependency 'httparty'
+  spec.add_runtime_dependency 'numbers_in_words'
+  spec.add_runtime_dependency 'activesupport'
+  spec.add_runtime_dependency 'chronic'
+  spec.add_runtime_dependency 'chronic_duration'
+  spec.add_runtime_dependency 'sinatra'
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "webmock"
+
+  spec.add_development_dependency "codeclimate-test-reporter"
+end

data/lib/alexa_hue/custom_slots.rb

@@ -0,0 +1,7 @@
+module Sinatra
+  module Hue
+    def self.custom_slots
+      File.read(File.expand_path('../../../skills_config/custom_slots.txt', __FILE__))
+    end
+  end
+end

data/lib/alexa_hue/fix_schedule_syntax.rb

@@ -0,0 +1,19 @@
+def fix_schedule_syntax(string)
+  sub_time = string.match(/time \d{2}:\d{2}/)
+  sub_duration = string.match(/schedule PT(?:(\d+)H)?(?:(\d+)M)?(?:(\d+)S)?/)
+
+  if sub_time
+    sub_time = sub_time.to_s
+    string.slice!(sub_time).strip
+    string << " #{sub_time}"
+    string.sub!("time", "schedule at")
+  end
+
+  if sub_duration
+    sub_duration = sub_duration.to_s
+    string.slice!(sub_duration).strip
+    sub_duration = ChronicDuration.parse(sub_duration.split(' ').last)
+    string << " schedule in #{sub_duration} seconds"
+  end
+  string.strip if string
+end

data/lib/alexa_hue/hue_switch.rb

@@ -0,0 +1,522 @@
+require 'net/http'
+require 'uri'
+require 'socket'
+require 'ipaddr'
+require 'timeout'
+require 'chronic'
+require 'chronic_duration'
+require 'httparty'
+require 'numbers_in_words'
+require 'numbers_in_words/duck_punch'
+require 'timeout'
+
+module Hue
+  module_function
+
+  def devices(options = {})
+    SSDP.new(options).devices
+  end
+
+  def first(options = {})
+    options = options.merge(:first => true)
+    SSDP.new(options).devices
+  end
+
+  class Switch
+    attr_accessor :command, :lights_array, :_group, :body, :schedule_params, :schedule_ids
+    def initialize(command = "", _group = 0, &block)
+
+      @user = "1234567890"
+        begin
+          @ip = HTTParty.get("https://www.meethue.com/api/nupnp").first["internalipaddress"] rescue nil
+          if @ip.nil?
+            bridge = get_bridge_by_SSDP
+            @ip = bridge.ip
+          end
+
+        rescue Timeout::Error
+          puts "Time Out"
+        rescue NoMethodError
+          puts "Cannot Find Bridge via Hue broker service, trying SSDP..."
+        rescue Errno::ECONNREFUSED
+          puts "Connection refused"
+        rescue SocketError
+          puts "Cannot connect to local network"
+        end
+
+      authorize_user
+      populate_switch
+
+      self.lights_array = []
+      self.schedule_ids = []
+      self.schedule_params = nil
+      self.command = ""
+      self._group = "0"
+      self.body = {}
+      instance_eval(&block) if block_given?
+    end
+
+    def list_lights
+      light_list = {}
+      HTTParty.get("http://#{@ip}/api/#{@user}/lights").each { |k,v| light_list["#{v['name']}".downcase] = k }
+      light_list
+    end
+
+    def list_groups
+      group_list = {}
+      HTTParty.get("http://#{@ip}/api/#{@user}/groups").each { |k,v| group_list["#{v['name']}".downcase] = k }
+      group_list["all"] = "0"
+      group_list
+    end
+
+    def list_scenes
+      scene_list = {}
+      HTTParty.get("http://#{@ip}/api/#{@user}/scenes").each do |scene|
+        if scene[1]["owner"] != "none"
+          inner = {"id" => scene[0]}.merge(scene[1])
+          scene_list.merge!({"#{scene[1]["name"].split(' ').first.downcase}" => inner})
+        end
+      end
+      scene_list
+    end
+
+    def hue (numeric_value)
+      clear_attributes
+      self.body[:hue] = numeric_value
+    end
+
+    def mired (numeric_value)
+      clear_attributes
+      self.body[:ct] = numeric_value
+    end
+
+    def color(color_name)
+      clear_attributes
+      if @colors.keys.include?(color_name.to_sym)
+        self.body[:hue] = @colors[color_name.to_sym]
+      else
+        self.body[:ct] = @mired_colors[color_name.to_sym]
+      end
+    end
+
+    def saturation(depth)
+      self.body.delete(:scene)
+      self.body[:sat] = depth
+    end
+
+    def brightness(depth)
+      self.body.delete(:scene)
+      self.body[:bri] = depth
+    end
+
+    def clear_attributes
+      self.body.delete(:scene)
+      self.body.delete(:ct)
+      self.body.delete(:hue)
+    end
+
+    def fade(in_seconds)
+      self.body[:transitiontime] = in_seconds * 10
+    end
+
+    def light (*args)
+      self.lights_array = []
+      self._group = ""
+      self.body.delete(:scene)
+      args.each { |l| self.lights_array.push @lights[l.to_s] if @lights.keys.include?(l.to_s) }
+    end
+
+    def lights(group_name)
+      self.lights_array = []
+      self.body.delete(:scene)
+      group = @groups[group_name.to_s]
+      self._group = group if !group.nil?
+    end
+
+    def scene(scene_name)
+      clear_attributes
+      scene_details = self.list_scenes[scene_name]
+      self.lights_array = scene_details["lights"]
+      self._group = "0"
+      self.body[:scene] = scene_details["id"]
+    end
+
+    def confirm
+      params = {:alert => 'select'}
+      HTTParty.put("http://#{@ip}/api/#{@user}/groups/0/action" , :body => params.to_json)
+    end
+
+    def save_scene(scene_name)
+      scene_name.gsub!(' ','-')
+      self.fade 2 if self.body[:transitiontime] == nil
+      if self._group.empty?
+        light_group = HTTParty.get("http://#{@ip}/api/#{@user}/groups/0")["lights"]
+      else
+        light_group = HTTParty.get("http://#{@ip}/api/#{@user}/groups/#{self._group}")["lights"]
+      end
+      params = {name: scene_name, lights: light_group, transitiontime: self.body[:transitiontime]}
+      response = HTTParty.put("http://#{@ip}/api/#{@user}/scenes/#{scene_name}", :body => params.to_json)
+      confirm if response.first.keys[0] == "success"
+    end
+
+    def lights_on_off
+      self.lights_array.each { |l| HTTParty.put("http://#{@ip}/api/#{@user}/lights/#{l}/state", :body => (self.body).to_json) }
+    end
+
+    def group_on_off
+      HTTParty.put("http://#{@ip}/api/#{@user}/groups/#{self._group}/action", :body => (self.body.reject { |s| s == :scene }).to_json)
+    end
+
+    def scene_on_off
+      if self.body[:on] == true
+        HTTParty.put("http://#{@ip}/api/#{@user}/groups/#{self._group}/action", :body => (self.body.select { |s| s == :scene }).to_json)
+      elsif self.body[:on] == false
+        # turn off individual lights in the scene
+        (HTTParty.get("http://#{@ip}/api/#{@user}/scenes"))[self.body[:scene]]["lights"].each do |l|
+          puts self.body
+          HTTParty.put("http://#{@ip}/api/#{@user}/lights/#{l}/state", :body => (self.body).to_json)
+        end
+      end
+    end
+
+    def on
+      self.body[:on]=true
+      lights_on_off if self.lights_array.any?
+      group_on_off if (!self._group.empty? && self.body[:scene].nil?)
+      scene_on_off if !self.body[:scene].nil?
+    end
+
+    def off
+      self.body[:on]=false
+      lights_on_off if self.lights_array.any?
+      group_on_off if (!self._group.empty? && self.body[:scene].nil?)
+      scene_on_off if !self.body[:scene].nil?
+    end
+
+    # Parses times in words (e.g., "eight forty five") to standard HH:MM format
+
+    def schedule (string, on_or_off = :default)
+      self.body[:on] = true if on_or_off == :on
+      self.body[:on] = false if on_or_off == :off
+      set_time = set_time(string)
+      if set_time < Time.now
+        p "You've scheduled this in the past"
+      else
+        set_time = set_time.to_s.split(' ')[0..1].join(' ').sub(' ',"T")
+        self.schedule_params = {:name=>"Hue_Switch Alarm",
+               :description=>"",
+               :localtime=>"#{set_time}",
+               :status=>"enabled",
+               :autodelete=>true
+              }
+        if self.lights_array.any?
+          lights_array.each do |l|
+            self.schedule_params[:command] = {:address=>"/api/#{@user}/lights/#{l}/state", :method=>"PUT", :body=>self.body}
+          end
+        else
+          self.schedule_params[:command] = {:address=>"/api/#{@user}/groups/#{self._group}/action", :method=>"PUT", :body=>self.body}
+        end
+        self.schedule_ids.push(HTTParty.post("http://#{@ip}/api/#{@user}/schedules", :body => (self.schedule_params).to_json))
+        confirm if self.schedule_ids.flatten.last.include?("success")
+      end
+    end
+
+    def delete_schedules!
+      self.schedule_ids.flatten!
+      self.schedule_ids.each { |k|
+        id = k["success"]["id"] if k.include?("success")
+        HTTParty.delete("http://#{@ip}/api/#{@user}/schedules/#{id}")
+      }
+      self.schedule_ids = []
+    end
+
+    def colorloop(start_or_stop)
+      if start_or_stop == :start
+        self.body[:effect] = "colorloop"
+      elsif start_or_stop == :stop
+        self.body[:effect] = "none"
+      end
+    end
+
+    def alert(value)
+      if value == :short
+        self.body[:alert] = "select"
+      elsif value == :long
+        self.body[:alert] = "lselect"
+      elsif value == :stop
+        self.body[:alert] = "none"
+      end
+    end
+
+    def reset
+      self.command = ""
+      self._group = "0"
+      self.body = {}
+      self.schedule_params = nil
+    end
+
+    #The following two methods are required to use Switch with Zach Feldman's Alexa-home*
+    def wake_words
+      ["light", "lights", "scene", "seen"]
+    end
+
+    def process_command (command)
+      command.sub!("color loop", "colorloop")
+      command.sub!("too", "two")
+      command.sub!("for", "four")
+      command.sub!(/a half$/, 'thirty seconds')
+      self.voice command
+    end
+
+    #The rest of the methods allow access to most of the Switch class functionality by supplying a single string
+
+    def voice(string)
+      puts string
+      self.reset
+      self.command << string
+
+      parse_voice(string)
+
+      if self.command.include?("schedule")
+        state = string.match(/off|on/)[0].to_sym rescue nil
+        self.send("schedule", *[string, state])
+      else
+        string.include?(' off') ? self.send("off") : self.send("on")
+      end
+    end
+
+    private
+
+    def parse_leading(methods)
+      methods.each do |l|
+        capture = (self.command.match (/\b#{l}\s\w+/)).to_s.split(' ')
+        method = capture[0]
+        value = capture[1]
+        value = value.in_numbers if value.scan(Regexp.union( (1..10).map {|k| k.in_words} ) ).any?
+        value = ((value.to_f/10.to_f)*255).to_i if (value.class == Fixnum) && (l != "fade")
+        self.send( method, value )
+      end
+    end
+
+    def parse_trailing(method)
+      all_keys = Regexp.union((@groups.keys + @lights.keys).flatten)
+      value = self.command.match(all_keys).to_s
+      self.send( method.first, value )
+    end
+
+    def parse_dynamic(methods)
+    methods.each do |d|
+        capture = (self.command.match (/\w+ #{d}\b/)).to_s.split(' ')
+        method = capture[1]
+        value = capture[0].to_sym
+        self.send( method, value )
+      end
+    end
+
+    def parse_scene(scene_name)
+      scene_name.gsub!(' ','-') if scene_name.size > 1
+      self.send("scene", scene_name)
+    end
+
+    def parse_save_scene
+      save_scene = self.command.partition(/save (scene|seen) as /).last
+      self.send( "save_scene", save_scene)
+    end
+
+    def parse_voice(string)
+      string.gsub!('schedule ','')
+      trailing = string.split(' ') & %w[lights light]
+      leading = string.split(' ') & %w[hue brightness saturation fade color]
+      dynamic = string.split(' ') & %w[colorloop alert]
+      scene_name = string.partition(" scene").first
+
+      parse_scene(scene_name) if string.include?(" scene") && !string.include?("save")
+      parse_leading(leading) if leading.any?
+      parse_trailing(trailing) if trailing.any?
+      parse_dynamic(dynamic) if dynamic.any?
+      parse_save_scene if self.command.scan(/save (scene|seen) as/).length > 0
+    end
+
+    def numbers_to_times(numbers)
+      numbers.map!(&:in_numbers)
+      numbers.map!(&:to_s)
+      numbers.push("0") if numbers[1] == nil
+      numbers = numbers.shift + ':' + (numbers[0].to_i + numbers[1].to_i).to_s
+      numbers.gsub!(':', ':0') if numbers.split(":")[1].length < 2
+      numbers
+    end
+
+    def parse_time(string)
+      string.sub!(" noon", " twelve in the afternoon")
+      string.sub!("midnight", "twelve in the morning")
+      time_modifier = string.downcase.scan(/(evening)|(night|tonight)|(afternoon)|(pm)|(a.m.)|(am)|(p.m.)|(morning)|(today)/).flatten.compact.first
+      guess = Time.now.strftime('%H').to_i >= 12 ?  "p.m." : "a.m."
+      time_modifier = time_modifier.nil? ? guess : time_modifier
+      day_modifier = string.scan(/(tomorrow)|(next )?(monday|tuesday|wednesday|thursday|friday|saturday|sunday)/).flatten.compact.join(' ')
+      numbers_in_words = string.scan(Regexp.union((1..59).map(&:in_words)))
+      set_time = numbers_to_times(numbers_in_words)
+      set_time = Chronic.parse(day_modifier +  ' ' + set_time + ' ' + time_modifier)
+    end
+
+    def set_time(string)
+      if string.scan(/ seconds?| minutes?| hours?| days?| weeks?/).any?
+        set_time = string.partition("in").last.strip!
+        set_time = Time.now + ChronicDuration.parse(string)
+      elsif string.scan(/\d/).any?
+        set_time = string.partition("at").last.strip!
+        set_time = Chronic.parse(set_time)
+      else
+        set_time = string.partition("at").last.strip!
+        set_time = parse_time(set_time)
+      end
+    end
+
+    def authorize_user
+      begin
+        if HTTParty.get("http://#{@ip}/api/#{@user}/config").include?("whitelist") == false
+          body = {:devicetype => "Hue_Switch", :username=>"1234567890"}
+          create_user = HTTParty.post("http://#{@ip}/api", :body => body.to_json)
+          puts "You need to press the link button on the bridge and run again" if create_user.first.include?("error")
+        end
+      rescue Errno::ECONNREFUSED
+        puts "Cannot Reach Bridge"
+      end
+    end
+
+    def populate_switch
+      @colors = {red: 65280, pink: 56100, purple: 52180, violet: 47188, blue: 46920, turquoise: 31146, green: 25500, yellow: 12750, orange: 8618}
+      @mired_colors = {candle: 500, relax: 467, reading: 346, neutral: 300, concentrate: 231, energize: 136}
+      @scenes = [] ; HTTParty.get("http://#{@ip}/api/#{@user}/scenes").keys.each { |k| @scenes.push(k) }
+      @groups = {} ; HTTParty.get("http://#{@ip}/api/#{@user}/groups").each { |k,v| @groups["#{v['name']}".downcase] = k } ; @groups["all"] = "0"
+      @lights = {} ; HTTParty.get("http://#{@ip}/api/#{@user}/lights").each { |k,v| @lights["#{v['name']}".downcase] = k }
+    end
+
+    def get_bridge_by_SSDP
+      discovered_devices = Hue.devices
+      bridge = discovered_devices.each do |device|
+          next unless device.get_response.include?("hue Personal")
+      end.first
+    end
+  end
+
+
+  # The Device and SSDP classes are basically lifted from Sam Soffes' great GitHub repo:
+  # https://github.com/soffes/discover.
+
+  class Device
+    attr_reader :ip
+    attr_reader :port
+    attr_reader :description_url
+    attr_reader :server
+    attr_reader :service_type
+    attr_reader :usn
+    attr_reader :url_base
+    attr_reader :name
+    attr_reader :manufacturer
+    attr_reader :manufacturer_url
+    attr_reader :model_name
+    attr_reader :model_number
+    attr_reader :model_description
+    attr_reader :model_url
+    attr_reader :serial_number
+    attr_reader :software_version
+    attr_reader :hardware_version
+
+    def initialize(info)
+      headers = {}
+      info[0].split("\r\n").each do |line|
+        matches = line.match(/^([\w\-]+):(?:\s)*(.*)$/)
+        next unless matches
+        headers[matches[1].upcase] = matches[2]
+      end
+
+      @description_url = headers['LOCATION']
+      @server = headers['SERVER']
+      @service_type = headers['ST']
+      @usn = headers['USN']
+
+      info = info[1]
+      @port = info[1]
+      @ip = info[2]
+    end
+
+    def get_response
+      Net::HTTP.get_response(URI.parse(description_url)).body
+    end
+  end
+
+  class SSDP
+    # SSDP multicast IPv4 address
+    MULTICAST_ADDR = '239.255.255.250'.freeze
+
+    # SSDP UDP port
+    MULTICAST_PORT = 1900.freeze
+
+    # Listen for all devices
+    DEFAULT_SERVICE_TYPE = 'ssdp:all'.freeze
+
+    # Timeout in 2 seconds
+    DEFAULT_TIMEOUT = 2.freeze
+
+    attr_reader :service_type
+    attr_reader :timeout
+    attr_reader :first
+
+    # @param service_type [String] the identifier of the device you're trying to find
+    # @param timeout [Fixnum] timeout in seconds
+    def initialize(options = {})
+      @service_type = options[:service_type]
+      @timeout = (options[:timeout] || DEFAULT_TIMEOUT)
+      @first = options[:first]
+      initialize_socket
+    end
+
+    # Look for devices on the network
+    def devices
+      @socket.send(search_message, 0, MULTICAST_ADDR, MULTICAST_PORT)
+      listen_for_responses(first)
+    end
+
+  private
+
+    def listen_for_responses(first = false)
+      @socket.send(search_message, 0, MULTICAST_ADDR, MULTICAST_PORT)
+
+      devices = []
+      Timeout::timeout(timeout) do
+        loop do
+          device = Device.new(@socket.recvfrom(2048))
+          next if service_type && service_type != device.service_type
+
+          if first
+            return device
+          else
+            devices << device
+          end
+        end
+      end
+      devices
+
+    rescue Timeout::Error => ex
+      devices
+    end
+
+    def initialize_socket
+      # Create a socket
+      @socket = UDPSocket.open
+
+      # We're going to use IP with the multicast TTL. Mystery third parameter is a mystery.
+      @socket.setsockopt(Socket::IPPROTO_IP, Socket::IP_MULTICAST_TTL, 2)
+    end
+
+    def search_message
+     [
+        'M-SEARCH * HTTP/1.1',
+        "HOST: #{MULTICAST_ADDR}:reservedSSDPport",
+        'MAN: ssdp:discover',
+        "MX: #{timeout}",
+        "ST: #{service_type || DEFAULT_SERVICE_TYPE}"
+      ].join("\n")
+    end
+  end
+end

data/lib/alexa_hue/intent_schema.rb

@@ -0,0 +1,7 @@
+module Sinatra
+  module Hue
+    def self.intent_schema
+      File.read(File.expand_path('../../../skills_config/intent_schema.txt', __FILE__))
+    end
+  end
+end

data/lib/alexa_hue/sample_utterances.rb

@@ -0,0 +1,7 @@
+module Sinatra
+  module Hue
+    def self.sample_utterances
+      File.read(File.expand_path('../../../skills_config/sample_utterances.txt', __FILE__))
+    end
+  end
+end

data/lib/alexa_hue/version.rb

@@ -0,0 +1,5 @@
+module Sinatra
+  module Hue
+    VERSION = "1.0.0"
+  end
+end

data/lib/alexa_hue.rb

@@ -0,0 +1,144 @@
+require 'json'
+require 'alexa_objects'
+require 'httparty'
+require 'numbers_in_words'
+require 'numbers_in_words/duck_punch'
+require 'chronic'
+require 'alexa_hue/version'
+require 'sinatra/base'
+require 'numbers_in_words/duck_punch'
+require 'alexa_hue/hue_switch'
+require 'chronic_duration'
+require 'alexa_hue/fix_schedule_syntax'
+
+
+LEVELS = {} ; [*1..10].each { |t| LEVELS[t.to_s ] = t.in_words }
+
+module Sinatra
+  module Hue
+    def self.registered(app)
+      app.post '/alexa_hue' do
+        content_type :json
+
+        # halt 400, "Invalid Application ID" unless @application_id == "your application id here"
+        
+        # Behavior for Launch Request
+        if @echo_request.launch_request?
+          response = AlexaObjects::Response.new
+          response.spoken_response = "I'm ready to control the lights"
+          response.end_session = false
+          response.without_card.to_json
+        
+        # Behavior for ControlLights intent. Keys and values need to be adjusted a bit to work with HueSwitch #voice syntax.
+        elsif @echo_request.intent_name == "ControlLights"
+        if @echo_request.slots.brightness
+          LEVELS.keys.reverse_each { |level| @echo_request.slots.brightness.sub!(level, LEVELS[level]) } if @echo_request.slots.schedule.nil? 
+        end
+
+        if @echo_request.slots.saturation
+          LEVELS.keys.reverse_each { |level| @echo_request.slots.saturation.sub!(level, LEVELS[level]) } if @echo_request.slots.schedule.nil?
+        end
+
+        puts @echo_request.slots
+        @echo_request.slots.to_h.each do |k,v| 
+          @string ||= ""
+          next unless v
+          if k == :scene || k == :alert
+            @string << "#{v.to_s} #{k.to_s}  "
+          elsif k == :lights || k == :modifier || k == :state
+            @string << "#{v.to_s}  "
+          elsif k == :savescene
+            @string << "save scene as #{v.to_s} "
+          elsif k == :flash
+            @string << "start long alert "
+          else
+            @string << "#{k.to_s} #{v.to_s}  "
+          end
+        end
+        
+        fix_schedule_syntax(@string)        
+        @string.sub!("color loop", "colorloop")
+        @string.strip!
+ 
+        begin
+          switch = Hue::Switch.new
+        rescue RuntimeError
+          response = AlexaObjects::Response.new
+          response.end_session = true
+          response.spoken_response = "Hello. Before using Hue lighting, you'll need to give me access to your Hue bridge." +
+                              " Please press the link button on your bridge and launch the skill again within ten seconds."
+          halt response.without_card.to_json
+        end
+        
+        if @echo_request.slots.lights.nil? && @echo_request.slots.scene.nil? && @echo_request.slots.savescene.nil?
+          r = AlexaObjects::Response.new
+          r.end_session = false
+          r.spoken_response = "Please specify which light or lights you'd like to adjust. I'm ready to control the lights."
+          halt r.without_card.to_json
+        end
+
+         if @echo_request.slots.lights
+          if @echo_request.slots.lights.scan(/light|lights/).empty?
+            r = AlexaObjects::Response.new
+            r.end_session = false
+            r.spoken_response = "Please specify which light or lights you'd like to adjust. I'm ready to control the lights."
+            halt r.without_card.to_json
+          end
+        end
+
+        puts @echo_request.slots.lights
+        if @echo_request.slots.lights
+        if @echo_request.slots.lights.include?('lights')
+           puts switch.list_groups.keys.join(', ').downcase
+          if !(switch.list_groups.keys.join(', ').downcase.include?("#{@echo_request.slots.lights.sub(' lights','')}"))
+            r = AlexaObjects::Response.new
+            r.end_session = true
+            r.spoken_response = "I couldn't find a group with the name #{@echo_request.slots.lights}"
+            halt r.without_card.to_json
+          end
+
+        elsif  @echo_request.slots.lights.include?('light')
+          if  !(switch.list_lights.keys.join(', ').downcase.include?("#{@echo_request.slots.lights.sub(' light','')}"))
+            r = AlexaObjects::Response.new
+            r.end_session = true
+            r.spoken_response = "I couldn't find a light with the name #{@echo_request.slots.lights}"
+            halt r.without_card.to_json
+          end
+        end
+      end
+        
+
+        #if  @string.include?('light ')
+        #  if (@string.split(' ') & switch.list_lights.keys.join(', ').downcase.split(', ')).empty?
+        #    r = AlexaObjects::Response.new
+        #    r.end_session = true
+        #    r.spoken_response = "I couldn't find a light with the name #{@echo_request.slots.lights}"
+        #    halt r.without_card.to_json
+        #  end
+        #end
+        switch.voice @string 
+
+        response = AlexaObjects::Response.new
+        response.end_session = true
+        response.spoken_response = "okay"
+        response.card_content =  "#{@string}...#{@data}"
+        response.without_card.to_json # change to .with_card.to_json for debugging info
+          
+        # Behavior for End Session requests.
+        elsif @echo_request.intent_name == "EndSession"
+          response = AlexaObjects::Response.new
+          response.end_session = true
+          response.spoken_response = "exiting lighting"
+          response.without_card.to_json
+        
+        elsif @echo_request.session_ended_request?
+          response = AlexaObjects::Response.new
+          response.end_session = true
+          response.without_card.to_json
+        end
+      end
+    end
+  end
+
+  register Hue
+end

data/skills_config/custom_slots.txt

@@ -0,0 +1,46 @@
+LIGHTS
+bedroom lights
+fireplace lights
+floor light
+overhead light
+
+ATTRIBUTE
+Saturation
+Brightness
+
+COLOR
+Red
+Blue
+Green
+Yellow
+Pink
+Purple
+Violet
+Turquiose
+Reading
+Relax
+Candle
+Neutral
+Concentrate
+
+LEVEL
+one
+two
+three
+four
+five
+six
+seven
+eight
+nine
+ten
+
+SCENE
+morning
+evening
+dinner
+afternoon
+
+STATE
+on
+off

data/skills_config/intent_schema.txt

@@ -0,0 +1,65 @@
+{
+  "intents": [
+    {
+      "intent": "ControlLights",
+      "slots": [
+        {
+          "name": "Lights",
+          "type": "LIGHTS"
+        },
+        {
+          "name": "Brightness",
+          "type": "LEVEL"
+        },
+        {
+          "name": "Saturation",
+          "type": "LEVEL"
+        },
+        {
+          "name": "Start",
+          "type": "AMAZON.LITERAL"
+        },
+        {
+          "name": "Stop",
+          "type": "AMAZON.LITERAL"
+        },
+        {
+          "name": "State",
+          "type": "STATE"
+        },
+        {
+          "name": "SaveScene",
+          "type": "AMAZON.LITERAL"
+        },
+        {
+          "name": "String",
+          "type": "AMAZON.LITERAL"
+        },
+        {
+          "name": "Color",
+          "type": "COLOR"
+        },
+        {
+          "name": "Schedule",
+          "type": "AMAZON.DURATION"
+        },
+        {
+          "name": "Time",
+          "type": "AMAZON.TIME"
+        },
+         {
+          "name": "Flash",
+          "type": "AMAZON.LITERAL"
+        },
+        {
+          "name": "Scene",
+          "type": "SCENE"
+        },
+        {
+          "name": "EndSession",
+          "type": "AMAZON.LITERAL"
+        }
+      ] 
+    }
+  ]
+}

data/skills_config/sample_utterances.txt

@@ -0,0 +1,68 @@
+ControlLights turn the {Lights} {State}
+ControlLights turn {State} the {Lights}
+ControlLights set {Scene} scene
+ControlLights set scene {Scene}
+ControlLights set the scene {Scene}
+
+ControlLights turn the {Lights} {Color}
+ControlLights turn the {Lights} to {Color}
+ControlLights turn the {Lights} to the {Color}
+ControlLights change the {Lights} to {Color}
+ControlLights change the {Lights} to the {Color}
+ControlLights set the {Lights} to {Color}
+ControlLights set the {Lights} to the {Color}
+
+ControlLights turn {State} the {Lights} in {Schedule}
+ControlLights turn the {Lights} {State} in {Schedule}
+ControlLights turn the {Lights} {Color} in {Schedule}
+ControlLights turn the {Lights} to {Color} in {Schedule}
+ControlLights turn the {Lights} to the {Color} in {Schedule}
+ControlLights change the {Lights} to {Color} in {Schedule}
+ControlLights change the {Lights} to the {Color} in {Schedule}
+ControlLights set the {Lights} to {Color} in {Schedule}
+ControlLights set the {Lights} to the {Color} in {Schedule}
+
+ControlLights turn {State} the {Lights} at {Time}
+ControlLights turn the {Lights} {State} at {Time}
+ControlLights turn the {Lights} {Color} at {Time}
+ControlLights turn the {Lights} to {Color} at {Time}
+ControlLights turn the {Lights} to the {Color} at {Time}
+ControlLights change the {Lights} to {Color} at {Time}
+ControlLights change the {Lights} to the {Color} at {Time}
+ControlLights set the {Lights} to {Color} at {Time}
+ControlLights set the {Lights} to the {Color} at {Time}
+
+ControlLights {Lights} brightness {Brightness} 
+ControlLights set the {Lights} to brightness {Brightness}
+ControlLights raise the {Lights} to brightness {Brightness}
+ControlLights dim the {Lights} to brightness {Brightness}
+ControlLights {Lights} saturation {Saturation} 
+ControlLights set the {Lights} to saturation {Saturation}
+
+
+ControlLights set the {Lights} to the color {Color} and saturation {Saturation}
+ControlLights set the {Lights} to the color {Color} and brightness {Brightness} 
+ControlLights set the {Lights} to the color {Color} and saturation {Saturation} in {Schedule}
+ControlLights set the {Lights} to the color {Color} and brightness {Brightness} in {Schedule}
+
+ControlLights start {short alert|Start} on the {Lights}
+ControlLights start {long alert|Start} on the {Lights}
+ControlLights start {color loop|Start} on the {Lights}
+ControlLights stop {alert|Stop}
+ControlLights stop {color loop|Stop}
+
+ControlLights {flash|Flash} {Lights}
+ControlLights {flash|Flash} {Lights} in {Schedule}
+ControlLights {flash|Flash} the {Lights}
+ControlLights {flash|Flash} the {Lights} in {Schedule}
+
+ControlLights save scene as {romantic|SaveScene}
+ControlLights save scene as {summer dawn|SaveScene}
+ControlLights save scene as {working at night|SaveScene}
+ControlLights save scene as {purple|SaveScene}
+ControlLights save scene as {midnight cave|SaveScene}
+
+ControlLights {exit|EndSession}
+ControlLights {quit|EndSession}
+ControlLights {enough|EndSession}
+ControlLights {stop|EndSession}

metadata

@@ -0,0 +1,245 @@
+--- !ruby/object:Gem::Specification
+name: alexa_hue
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Kyle Lucas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: alexa_objects
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: numbers_in_words
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: chronic
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: chronic_duration
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: webmock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: ''
+email:
+- kglucas93@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".DS_Store"
+- ".gitignore"
+- Gemfile
+- Guardfile
+- Rakefile
+- alexa_hue.gemspec
+- lib/alexa_hue.rb
+- lib/alexa_hue/custom_slots.rb
+- lib/alexa_hue/fix_schedule_syntax.rb
+- lib/alexa_hue/hue_switch.rb
+- lib/alexa_hue/intent_schema.rb
+- lib/alexa_hue/sample_utterances.rb
+- lib/alexa_hue/version.rb
+- skills_config/.DS_Store
+- skills_config/custom_slots.txt
+- skills_config/intent_schema.txt
+- skills_config/sample_utterances.txt
+homepage: http://github.com/kylegrantlucas/alexa_hue
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- skills_config
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: A sinatra middleware for alexa hue actions.
+test_files: []
+has_rdoc: