spark_api 1.1.2 → 1.2.0

data/lib/spark_api/authentication/oauth2_impl/faraday_middleware.rb

@@ -35,6 +35,34 @@ module SparkApi
 
       end
       Faraday.register_middleware :response, :oauth2_impl => FaradayMiddleware
+      
+      #==OAuth2 Faraday response middleware
+      # HTTP Response after filter to package oauth2 responses and bubble up basic api errors.
+      class SparkbarFaradayMiddleware < Faraday::Response::Middleware
+  
+        def initialize(app)
+          super(app)
+        end
+  
+        def on_complete(env)
+          body = MultiJson.decode(env[:body])
+          SparkApi.logger.debug("[sparkbar] Response Body: #{body.inspect}")
+          unless body.is_a?(Hash)
+            raise InvalidResponse, "The server response could not be understood"
+          end
+          case env[:status]
+          when 200..299
+            SparkApi.logger.debug("[sparkbar] Success!")
+            if body.include?("token")
+              env[:body] = body
+              return
+            end
+          end
+          raise ClientError, {:message => "Unable to process sparkbar token #{body.inspect}", :code =>0, :status => env[:status]}
+        end
+  
+      end
+      Faraday.register_middleware :response, :sparkbar_impl => SparkbarFaradayMiddleware
 
     end
   end

data/lib/spark_api/authentication/oauth2_impl/grant_type_base.rb

@@ -45,6 +45,11 @@ module SparkApi
           response.expires_in = provider.session_timeout if response.expires_in.nil?
           SparkApi.logger.debug("[oauth2] New session created #{response}")
           response
+        rescue Faraday::Error::ConnectionFailed => e
+          if @client.ssl_verify && e.message =~ /certificate verify failed/
+            SparkApi.logger.error(SparkApi::Errors.ssl_verification_error)
+          end
+          raise e
         end
                 
         def needs_refreshing?
@@ -66,9 +71,9 @@ module SparkApi
           opts = {
             :headers => @client.headers
           }
-          opts[:ssl] = {:verify => false }
+          
+          opts[:ssl] = {:verify => false } unless @client.ssl_verify
           opts[:url] = endpoint       
-          Faraday.register_middleware :response, :faraday_middleware => FaradayMiddleware
           conn = Faraday::Connection.new(opts) do |conn|
             conn.response :oauth2_impl
             conn.adapter Faraday.default_adapter

data/lib/spark_api/authentication/oauth2_impl/single_session_provider.rb

@@ -0,0 +1,27 @@
+module SparkApi
+  module Authentication
+
+    class SingleSessionProvider < BaseOAuth2Provider
+
+      def initialize(credentials)
+        @access_token = credentials.delete(:access_token)
+        super(credentials)
+      end
+
+      def load_session
+        @session ||= SparkApi::Authentication::OAuthSession.new({
+          :access_token => @access_token
+        })
+      end
+
+      def save_session session
+        @session = session
+      end
+
+      def destroy_session
+        @session = nil
+      end
+
+    end
+  end
+end

data/lib/spark_api/cli.rb

@@ -14,9 +14,13 @@ module SparkApi
   module CLI
     class ConsoleCLI
       OPTIONS_ENV = {
-        :endpoint          => "API_ENDPOINT",
+        :endpoint => "API_ENDPOINT",
+        :no_verify => "NO_VERIFY",
         # OAUTH2 Options
         :access_uri  => "ACCESS_URI",
+        :authorization_uri => "AUTHORIZATION_URI",
+        :redirect_uri => "REDIRECT_URI",
+        :code => "CODE",
         :username=> "USERNAME",
         :password=> "PASSWORD",
         :client_id=> "CLIENT_ID",
@@ -53,6 +57,9 @@ module SparkApi
           :endpoint          => ENV[OPTIONS_ENV[:endpoint]],
           # OAUTH2 Options
           :access_uri  => ENV[OPTIONS_ENV[:access_uri]],
+          :authorization_uri  => ENV[OPTIONS_ENV[:authorization_uri]],
+          :redirect_uri  => ENV[OPTIONS_ENV[:redirect_uri]],
+          :code  => ENV[OPTIONS_ENV[:code]],
           :username=> ENV[OPTIONS_ENV[:username]],
           :password=> ENV[OPTIONS_ENV[:password]],
           :client_id=> ENV[OPTIONS_ENV[:client_id]],
@@ -61,6 +68,7 @@ module SparkApi
           :api_key => ENV[OPTIONS_ENV[:api_key]], 
           :api_secret => ENV[OPTIONS_ENV[:api_secret]],
           :api_user => ENV[OPTIONS_ENV[:api_user]],
+          :no_verify => ENV.fetch(OPTIONS_ENV[:no_verify], false),
           :console => ENV[OPTIONS_ENV[:console]]
         }
         cli_options = {}
@@ -77,15 +85,15 @@ module SparkApi
             Options are:
           BANNER
           opts.separator ""
-          opts.on("-o","--oauth2",
-                  "Run the API using OAuth2 credentials.  The client defaults to using the Spark API authentication mode for access. ",
-                  "See http://sparkplatform.com/docs/authentication/authentication for more information on authentication types.",
-                  "Default: false") { |arg| cli_options[:oauth2] = arg }
           opts.on("-e","--endpoint ENDPOINT",
                   "URI of the API.",
-                  "Default: ENV['#{OPTIONS_ENV[:endpoint]}']") { |arg| cli_options[:endpoint] = arg }
+                  "Default: ENV['#{OPTIONS_ENV[:endpoint]}'] or #{SparkApi::Configuration::DEFAULT_ENDPOINT}") { |arg| cli_options[:endpoint] = arg }
 
           # OAUTH2
+          opts.on("-o","--oauth2",
+                  "Run the API using OAuth2 credentials.  The client defaults to using the Spark API authentication mode for access. ",
+                  "See http://sparkplatform.com/docs/authentication/authentication for more information on authentication types.",
+                  "Default: false") { |arg| cli_options[:oauth2] = arg }
           opts.on("--client_id CLIENT_ID",
                   "OAuth2 client id",
                   "Default: ENV['#{OPTIONS_ENV[:client_id]}']") { |arg| cli_options[:client_id] = arg }
@@ -99,9 +107,17 @@ module SparkApi
                   "OAuth2 password",
                   "Default: ENV['#{OPTIONS_ENV[:password]}']") { |arg| cli_options[:password] = arg }
           opts.on("--access_uri ACCESS_URI",
-                  "OAuth2 path for granting access to the application",
-                  "Default: ENV['#{OPTIONS_ENV[:access_uri]}']") { |arg| cli_options[:access_uri] = arg }
-                    
+                  "OAuth2 path for granting access to the application using one of the supported grant types.",
+                  "Default: ENV['#{OPTIONS_ENV[:access_uri]}'] or #{SparkApi::Configuration::DEFAULT_ACCESS_URI}") { |arg| cli_options[:access_uri] = arg }
+          opts.on("--redirect_uri REDIRECT_URI",
+                  "OAuth2 application redirect for the client id. This needs to match whatever value is saved for the application's client_id",
+                  "Default: ENV['#{OPTIONS_ENV[:redirect_uri]}'] or #{SparkApi::Configuration::DEFAULT_REDIRECT_URI}") { |arg| cli_options[:redirect_uri] = arg }
+          opts.on("--authorization_uri AUTHORIZATION_URI",
+                  "OAuth2 authorization endpoint for a user. This is where the user should go to sign in and authorize client id.",
+                  "Default: ENV['#{OPTIONS_ENV[:authorization_uri]}'] or #{SparkApi::Configuration::DEFAULT_AUTH_ENDPOINT}") { |arg| cli_options[:authorization_uri] = arg }
+          opts.on("--code CODE",
+                  "OAuth2 authorization code used for granting application access to the API for a user") { |arg| cli_options[:code] = arg }
+          
           # API AUTH
           opts.on("--api_key API_KEY",
                   "Authentication key for running the api using the default api authentication",
@@ -112,9 +128,12 @@ module SparkApi
           opts.on("--api_user API_USER",
                   "ID of the Spark user to run the client as.",
                   "Default: ENV['#{OPTIONS_ENV[:api_user]}']") { |arg| cli_options[:api_user] = arg }
-                    
+          
+          # General           
           opts.on("-f", "--file FILE",
                   "Load configuration for yaml file.") { |arg| file_options = parse_file_options(arg) }
+          opts.on("--no_verify",
+                  "Disable SSL Certificate verification. This is useful for development servers.") { |arg| cli_options[:no_verify] = arg }
           opts.on("-d", "--debug",
                   "Show detailed request logging information.") { |arg| cli_options[:debug] = arg }
           opts.on("-v", "--version",

data/lib/spark_api/cli/api_auth.rb

@@ -5,4 +5,5 @@ SparkApi.configure do |config|
   config.api_secret = ENV["API_SECRET"]
   config.api_user = ENV["API_USER"] if ENV["API_USER"]
   config.endpoint = ENV["API_ENDPOINT"] if ENV["API_ENDPOINT"]
+  config.ssl_verify = ! (ENV["NO_VERIFY"].downcase=='true') if ENV["NO_VERIFY"]
 end

data/lib/spark_api/cli/oauth2.rb

@@ -1,14 +1,29 @@
 require File.dirname(__FILE__) + "/../cli/setup"
 
+
 SparkApi.configure do |config|
-  config.oauth2_provider = SparkApi::Authentication::OAuth2Impl::PasswordProvider.new(
-                            :authorization_uri=> ENV["AUTH_URI"],
-                            :access_uri  => ENV["ACCESS_URI"],
-                            :username=> ENV["USERNAME"],
-                            :password=> ENV["PASSWORD"],
-                            :client_id=> ENV["CLIENT_ID"],
-                            :client_secret=> ENV["CLIENT_SECRET"]
-                          ) 
+  oauth = {
+    :authorization_uri=> ENV.fetch("AUTH_URI", SparkApi::Configuration::DEFAULT_AUTHORIZATION_URI),
+    :access_uri  => ENV.fetch("ACCESS_URI", SparkApi::Configuration::DEFAULT_ACCESS_URI),
+    :redirect_uri  => ENV.fetch("REDIRECT_URI", SparkApi::Configuration::DEFAULT_REDIRECT_URI),
+    :client_id=> ENV["CLIENT_ID"],
+    :client_secret=> ENV["CLIENT_SECRET"]
+  }
+  oauth[:username] = ENV["USERNAME"] if ENV.include?("USERNAME")
+  oauth[:password] = ENV["PASSWORD"] if ENV.include?("PASSWORD")
+  config.oauth2_provider = SparkApi::Authentication::OAuth2Impl::CLIProvider.new(oauth)
+  unless (oauth.include?(:username) && oauth.include?(:password))
+    config.oauth2_provider.grant_type = :authorization_code 
+    config.oauth2_provider.code = ENV["CODE"] if ENV.include?("CODE")
+  end
   config.authentication_mode = SparkApi::Authentication::OAuth2
   config.endpoint = ENV["API_ENDPOINT"] if ENV["API_ENDPOINT"]
+  config.ssl_verify = ! (ENV["NO_VERIFY"].downcase=='true') if ENV["NO_VERIFY"]
 end
+
+# Enables saving and loading serialized oauth2 sessions for the system user. 
+def persist_sessions! my_alias = nil
+  warn "Warning: persistent session mode saves access tokens in clear text on the filesystem."
+  SparkApi.client.oauth2_provider.session_alias = my_alias unless my_alias.nil?
+  SparkApi.client.oauth2_provider.persistent_sessions = true
+end

data/lib/spark_api/cli/setup.rb

@@ -45,3 +45,34 @@ include SparkApi::Models
 def c
   SparkApi.client
 end
+
+# Straight up HTTP functions y'all!!!
+
+def get(path, options={})
+  c.get(path, options)
+end
+
+def post(path, body = nil, options={})
+  c.post(path, body, options)
+end
+
+def put(path, body = nil, options={})
+  c.put(path, body, options)
+end
+
+def delete(path, options={})
+  c.delete(path, options)
+end
+
+# Handy session persistence
+def save_oauth2_session! session_alias = "default"
+  
+rescue => e
+  puts "Unable to save the oauth2 session: #{e.message}"
+end  
+
+def load_oauth2_session session_alias = "default"
+  c.oauth2_provider.session = ""
+rescue => e
+  puts "Unable to find a saved oauth2 session: #{e.message}"
+end

data/lib/spark_api/configuration.rb

@@ -5,13 +5,16 @@ module SparkApi
     
     # valid configuration options
     VALID_OPTION_KEYS = [:api_key, :api_secret, :api_user, :endpoint, 
-      :user_agent, :version, :ssl, :oauth2_provider, :authentication_mode, 
+      :user_agent, :version, :ssl, :ssl_verify, :oauth2_provider, :authentication_mode, 
       :auth_endpoint, :callback].freeze
     OAUTH2_KEYS = [:authorization_uri, :access_uri, :client_id, :client_secret,
       # Requirements for authorization_code grant type
       :redirect_uri,  
       # Requirements for password grant type
-      :username, :password
+      :username, :password,
+      # Requirements for single session keys
+      :access_token,
+      :sparkbar_uri
     ]
       
     require File.expand_path('../configuration/yaml', __FILE__)
@@ -23,10 +26,14 @@ module SparkApi
     DEFAULT_API_SECRET = nil
     DEFAULT_API_USER = nil
     DEFAULT_ENDPOINT = 'https://api.sparkapi.com'
+    DEFAULT_REDIRECT_URI = "https://sparkplatform.com/oauth2/callback"
     DEFAULT_AUTH_ENDPOINT = 'https://sparkplatform.com/openid'  # Ignored for Spark API Auth
+    DEFAULT_AUTHORIZATION_URI = 'https://sparkplatform.com/oauth2'
     DEFAULT_VERSION = 'v1'
+    DEFAULT_ACCESS_URI = "#{DEFAULT_ENDPOINT}/#{DEFAULT_VERSION}/oauth2/grant"
     DEFAULT_USER_AGENT = "Spark API Ruby Gem #{VERSION}"
     DEFAULT_SSL = true
+    DEFAULT_SSL_VERIFY = true
     DEFAULT_OAUTH2 = nil
     
     X_SPARK_API_USER_AGENT = "X-SparkApi-User-Agent"
@@ -57,6 +64,7 @@ module SparkApi
       self.oauth2_provider = DEFAULT_OAUTH2
       self.user_agent  = DEFAULT_USER_AGENT
       self.ssl         = DEFAULT_SSL
+      self.ssl_verify  = DEFAULT_SSL_VERIFY
       self.version     = DEFAULT_VERSION
       self
     end

data/lib/spark_api/configuration/yaml.rb

@@ -5,7 +5,7 @@ module SparkApi
   module Configuration
     class YamlConfig
       KEY_CONFIGURATIONS = VALID_OPTION_KEYS  + [:oauth2] + OAUTH2_KEYS  
-      DEFAULT_OAUTH2_PROVIDER = "SparkApi::Authentication::OAuth2Impl::PasswordProvider"
+      DEFAULT_OAUTH2_PROVIDER = "SparkApi::Authentication::OAuth2Impl::CLIProvider"
       attr_accessor *KEY_CONFIGURATIONS
       attr_reader :client_keys, :oauth2_keys, :provider
       
@@ -26,10 +26,15 @@ module SparkApi
       def oauth2?
         return oauth2 == true
       end
+
+      def ssl_verify?
+        return ssl_verify == true
+      end
       
       def name
         @name
       end
+      
       def api_env
         if env.include? "SPARK_API_ENV"
           env["SPARK_API_ENV"]

data/lib/spark_api/connection.rb

@@ -12,7 +12,7 @@ module SparkApi
         :headers => headers
       }
       if(force_ssl || self.ssl)
-        opts[:ssl] = {:verify => false }
+        opts[:ssl] = {:verify => false } unless self.ssl_verify
         opts[:url] = @endpoint.sub /^http:/, "https:"
       else 
         opts[:url] = @endpoint.sub /^https:/, "http:"

data/lib/spark_api/errors.rb

@@ -0,0 +1,48 @@
+module SparkApi
+  
+  # All known response codes listed in the API
+  module ResponseCodes
+    NOT_FOUND = 404
+    METHOD_NOT_ALLOWED = 405
+    INVALID_KEY = 1000
+    DISABLED_KEY = 1010
+    API_USER_REQUIRED = 1015
+    SESSION_TOKEN_EXPIRED = 1020
+    SSL_REQUIRED = 1030
+    INVALID_JSON = 1035
+    INVALID_FIELD = 1040
+    MISSING_PARAMETER = 1050
+    INVALID_PARAMETER = 1053
+    CONFLICTING_DATA = 1055
+    NOT_AVAILABLE= 1500
+    RATE_LIMIT_EXCEEDED = 1550
+  end
+  
+  # Errors built from API responses
+  class InvalidResponse < StandardError; end
+  class ClientError < StandardError
+    attr_reader :code, :status, :details
+    def initialize (options = {})
+      # Support the standard initializer for errors
+      opts = options.is_a?(Hash) ? options : {:message => options.to_s}
+      @code = opts[:code]
+      @status = opts[:status]
+      @details = opts[:details]
+      super(opts[:message])
+    end
+    
+  end
+  class NotFound < ClientError; end
+  class PermissionDenied < ClientError; end
+  class NotAllowed < ClientError; end
+  class BadResourceRequest < ClientError; end
+   
+  # =Errors
+  # Error messages and other error handling
+  module Errors
+    def self.ssl_verification_error
+      "SSL verification problem: if connecting to a trusted but non production API endpoint, " + 
+      "set 'ssl_verify' to false in the configuration or add '--no_verify' to the CLI command."
+    end
+  end
+end

data/lib/spark_api/models.rb

@@ -1,7 +1,9 @@
+require 'spark_api/models/dirty'
 require 'spark_api/models/base'
 require 'spark_api/models/constraint'
 require 'spark_api/models/finders'
 require 'spark_api/models/subresource'
+require 'spark_api/models/concerns'
 
 require 'spark_api/models/account'
 require 'spark_api/models/connect_prefs'
@@ -26,6 +28,7 @@ require 'spark_api/models/tour_of_home'
 require 'spark_api/models/video'
 require 'spark_api/models/virtual_tour'
 require 'spark_api/models/rental_calendar'
+require 'spark_api/models/subscription'
 
 module SparkApi
   module Models

data/lib/spark_api/models/account.rb

@@ -39,7 +39,15 @@ module SparkApi
       def primary_img(typ)
         if @images.is_a?(Array)
           matches = @images.select {|i| i.Type == typ}
-          matches.sort {|a,b| a.Name <=> b.Name }.first
+          matches.sort do |a,b| 
+            if a.Name.nil? && !b.Name.nil?
+              1
+            elsif b.Name.nil? && !a.Name.nil?
+              -1
+            else
+              a.Name.to_s <=> b.Name.to_s
+            end 
+          end.first
         else
           nil
         end

data/lib/spark_api/models/base.rb

@@ -5,10 +5,10 @@ module SparkApi
     # active model type niceties.
     class Base
       extend Paginate
+      include Dirty
 
       attr_accessor :attributes, :errors
-      attr_reader :changed
-      
+
       # Name of the resource as related to the path name
       def self.element_name
         # TODO I'd love to pull in active model at this point to provide default naming
@@ -18,7 +18,7 @@ module SparkApi
       def self.element_name=(name)
         @element_name = name
       end
-      
+
       # Resource path prefix, prepended to the url
       def self.prefix
         @prefix ||= "/"
@@ -29,7 +29,7 @@ module SparkApi
       def self.path
         "#{prefix}#{element_name}"
       end
-      
+
       def self.connection
         SparkApi.client
       end
@@ -40,7 +40,6 @@ module SparkApi
       def initialize(attributes={})
         @attributes = {}
         @errors = []
-        @changed = []
         load(attributes)
       end
 
@@ -49,7 +48,7 @@ module SparkApi
           @attributes[key.to_s] = val
         end
       end
-      
+
       def self.get(options={})
         collect(connection.get(path, options))
       end
@@ -61,28 +60,28 @@ module SparkApi
       def self.count(options={})
         connection.get(path, options.merge({:_pagination=>"count"}))
       end
-      
+
       def method_missing(method_symbol, *arguments)
         method_name = method_symbol.to_s
 
-        if method_name =~ /(=|\?)$/
+        if method_name =~ /(=|\?|_will_change!)$/
           case $1
           when "=" 
             write_attribute($`, arguments.first)
             # TODO figure out a nice way to present setters for the standard fields
           when "?" 
-            if attributes.include?($`)
-              attributes[$`] ? true : false
-            else
-              raise NoMethodError
-            end
+            raise NoMethodError unless attributes.include?($`)
+            attributes[$`] ? true : false
+          when "_will_change!"
+            raise NoMethodError unless attributes.include?($`)
+            attribute_will_change!($`)
           end 
         else
           return attributes[method_name] if attributes.include?(method_name)
           super # GTFO
         end
       end
-      
+
       def respond_to?(method_symbol, include_private=false)
         if super
           return true
@@ -93,26 +92,32 @@ module SparkApi
             true
           elsif method_name =~ /(\?)$/
             attributes.include?($`)
+          elsif method_name =~ /(\w*)_will_change!$/
+            attributes.include?($1)
           else
             attributes.include?(method_name)
           end
 
         end
       end
-      
+
       def parse_id(uri)
         uri[/\/.*\/(.+)$/, 1]
       end
-      
+
+      def persisted?
+        !(@attributes['Id'].nil? && @attributes['ResourceUri'].nil?)
+      end
+
       protected
-      
+
       def write_attribute(attribute,  value)
         unless attributes[attribute] == value
+          attribute_will_change!(attribute)
           attributes[attribute] = value
-          @changed << attribute unless @changed.include?(attribute)
         end
       end
-        
+
     end
   end
 end