spark_api 1.0.2 → 1.0.4

data/lib/spark_api/authentication/oauth2_impl/grant_type_password.rb~

@@ -1,45 +0,0 @@
-
-module FlexmlsApi
-  module Authentication
-    module OAuth2Impl
-      # OAuth2 authentication flow using username and password parameters for the user in the 
-      # request.  This implementation is geared towards authentication styles for native 
-      # applications that need to use OAuth2
-      class GrantTypePassword < GrantTypeBase
-        def initialize(client, provider, session)
-          super(client, provider, session)
-        end
-        def authenticate
-          new_session = nil
-          if needs_refreshing?
-            new_session = refresh
-          end
-          return new_session unless new_session.nil?
-          create_session(token_params)
-        end
-        
-        def refresh()
-          GrantTypeRefresh.new(client,provider,session).authenticate
-        rescue ClientError => e
-          FlexmlsApi.logger.info("[oauth2] Refreshing token failed, the library will try and authenticate from scratch: #{e.message}")
-          nil
-        end
-
-        private 
-        def token_params
-          params = {
-            "client_id" => @provider.client_id,
-            "client_secret" => @provider.client_secret,
-            "grant_type" => "password",
-            "username" => @provider.username,
-            "password" => @provider.password,
-          }.to_json 
-        end
-      end
-    end
-  end
-end
-
-
-
- 

data/lib/spark_api/authentication/oauth2_impl/grant_type_refresh.rb~

@@ -1,36 +0,0 @@
-
-module FlexmlsApi
-  module Authentication
-    # OAuth2 authentication flow to refresh an access token
-    module OAuth2Impl
-      class GrantTypeRefresh < GrantTypeBase
-        attr_accessor :params
-        def initialize(client, provider, session)
-          super(client, provider, session)
-          @params = {}
-        end
-        
-        def authenticate
-          new_session = nil
-          unless @session.refresh_token.nil?
-            FlexmlsApi.logger.debug("[oauth2] Refreshing authentication to #{provider.access_uri} using [#{session.refresh_token}]")
-            new_session = create_session(token_params)
-          end
-          new_session 
-        end
-        
-        private 
-        def token_params
-          @params.merge({
-            "client_id" => @provider.client_id,
-            "client_secret" => @provider.client_secret,
-            "grant_type" => "refresh_token",
-            "refresh_token"=> session.refresh_token,
-          }).to_json 
-        end
-      end
-      
-    end
-  end
-end
-

data/lib/spark_api/authentication/oauth2_impl/middleware.rb~

@@ -1,39 +0,0 @@
-
-module FlexmlsApi
-
-  module Authentication
-    
-    module OAuth2Impl
-      
-      #==OAuth2 Faraday response middleware
-      # HTTP Response after filter to package oauth2 responses and bubble up basic api errors.
-      class Middleware < Faraday::Response::ParseJson
-        def on_complete(finished_env)
-          body = parse(finished_env[:body])
-          FlexmlsApi.logger.debug("[oauth2] Response Body: #{body.inspect}")
-          unless body.is_a?(Hash)
-            raise InvalidResponse, "The server response could not be understood"
-          end
-          case finished_env[:status]
-          when 200..299
-            FlexmlsApi.logger.debug("[oauth2] Success!")
-            session = OAuthSession.new(body)
-          else 
-            # Handle the WWW-Authenticate Response Header Field if present. This can be returned by 
-            # OAuth2 implementations and wouldn't hurt to log.
-            auth_header_error = finished_env[:request_headers]["WWW-Authenticate"]
-            FlexmlsApi.logger.warn("Authentication error #{auth_header_error}") unless auth_header_error.nil?
-            raise ClientError, {:message => body["error"], :code =>0, :status => finished_env[:status]}
-          end
-          FlexmlsApi.logger.debug("[oauth2] Session=#{session.inspect}")
-          finished_env[:body] = session
-        end
-    
-        def initialize(app)
-          super(app)
-        end
-        
-      end
-    end
-  end
-end

data/lib/spark_api/authentication/oauth2_impl/password_provider.rb~

@@ -1,25 +0,0 @@
-
-module FlexmlsApi
-  module Authentication
-    module OAuth2Impl
-      class PasswordProvider < FlexmlsApi::Authentication::BaseOAuth2Provider
-        def initialize(credentials)
-          super(credentials)
-          @grant_type = :password
-        end
-        
-        def load_session()
-          @session
-        end
-      
-        def save_session(session)
-          @session = session
-        end
-      
-        def destroy_session
-          @session = nil
-        end
-      end
-    end
-  end
-end

data/lib/spark_api/cli.rb~

@@ -1,158 +0,0 @@
-require 'optparse'
-
-if ENV["SPARK_API_CONSOLE"].nil?
-  require 'spark_api'
-else
-  puts "Enabling console mode for local gem"
-  Bundler.require(:default, "development") if defined?(Bundler)
-  path = File.expand_path(File.dirname(__FILE__) + "/../../../lib/")
-  $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
-  require path + '/spark_api'
-end
-
-module SparkApi
-  module CLI
-    class ConsoleCLI
-      OPTIONS_ENV = {
-        :endpoint          => "API_ENDPOINT",
-        # OAUTH2 Options
-        :access_uri  => "ACCESS_URI",
-        :username=> "USERNAME",
-        :password=> "PASSWORD",
-        :client_id=> "CLIENT_ID",
-        :client_secret=> "CLIENT_SECRET",
-        # API AUTH Options
-        :api_key => "API_KEY", 
-        :api_secret => "API_SECRET",
-        :api_user => "API_USER",
-        # OTHER
-        :debug=> "DEBUG",
-        :console => "SPARK_API_CONSOLE"  # not a public option, meant to distinguish bin/spark_api and script/console
-      }
-      
-      def self.execute(stdout, arguments=[])
-        options = setup_options(stdout,arguments)
-        libs =  " -r irb/completion"
-        # Perhaps use a console_lib to store any extra methods I may want available in the cosole
-        libs << (options[:oauth2] ? setup_oauth2 : setup_api_auth)
-        
-        bundler = (options[:console] ? "bundle exec" : "")  
-        cmd = "#{export_env(options)} #{bundler} #{irb} #{libs} --simple-prompt"
-        puts "Loading spark_api gem..."
-        exec "#{cmd}"
-      end
-      
-      def self.irb()
-        RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
-      end
-      
-      private
-      def self.setup_options(stdout,arguments)
-        env_options = {
-          :oauth2            => false,
-          :endpoint          => ENV[OPTIONS_ENV[:endpoint]],
-          # OAUTH2 Options
-          :access_uri  => ENV[OPTIONS_ENV[:access_uri]],
-          :username=> ENV[OPTIONS_ENV[:username]],
-          :password=> ENV[OPTIONS_ENV[:password]],
-          :client_id=> ENV[OPTIONS_ENV[:client_id]],
-          :client_secret=> ENV[OPTIONS_ENV[:client_secret]],
-          # API AUTH Options
-          :api_key => ENV[OPTIONS_ENV[:api_key]], 
-          :api_secret => ENV[OPTIONS_ENV[:api_secret]],
-          :api_user => ENV[OPTIONS_ENV[:api_user]],
-          :console => ENV[OPTIONS_ENV[:console]]
-        }
-        cli_options = {}
-        file_options = {}
-        parser = OptionParser.new do |opts|
-          opts.banner = <<-BANNER.gsub(/^          /,'')
-            #{version}
-            SparkApi Client Console - http://www.flexmls.com/developers/api/
-            
-            Usage: #{File.basename($0)} [options]
-            
-            Environment Variables: some options (as indicated below), will default to values of keys set in the environment. 
-        
-            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://www.flexmls.com/developers/api/api-services/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 }
-
-          # OAUTH2
-          opts.on("--client_id CLIENT_ID",
-                  "OAuth2 client id",
-                  "Default: ENV['#{OPTIONS_ENV[:client_id]}']") { |arg| cli_options[:client_id] = arg }
-          opts.on("--client_secret CLIENT_SECRET",
-                  "OAuth2 client secret",
-                  "Default: ENV['#{OPTIONS_ENV[:client_secret]}']") { |arg| cli_options[:client_secret] = arg }
-          opts.on("-u","--username USERNAME",
-                  "OAuth2 username",
-                  "Default: ENV['#{OPTIONS_ENV[:username]}']") { |arg| cli_options[:username] = arg }
-          opts.on("-p","--password PASSWORD",
-                  "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 }
-                    
-          # API AUTH
-          opts.on("--api_key API_KEY",
-                  "Authentication key for running the api using the default api authentication",
-                  "Default: ENV['#{OPTIONS_ENV[:api_key]}']") { |arg| cli_options[:api_key] = arg }
-          opts.on("--api_secret API_SECRET",
-                  "API secret for the api key",
-                   "Default: ENV['#{OPTIONS_ENV[:api_secret]}']") { |arg| cli_options[:api_secret] = arg }
-          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 }
-                    
-          opts.on("-f", "--file FILE",
-                  "Load configuration for yaml file.") { |arg| file_options = parse_file_options(arg) }
-          opts.on("-d", "--debug",
-                  "Show detailed request logging information.") { |arg| cli_options[:debug] = arg }
-          opts.on("-v", "--version",
-                  "Show client version.") { stdout.puts version; exit }
-          opts.on("-h", "--help",
-                  "Show this help message.") { stdout.puts opts; exit }
-          opts.parse!(arguments)
-        
-        end
-        options = env_options.merge(file_options.merge(cli_options))
-        return options
-      end
-      
-      def self.setup_api_auth
-        " -r #{File.dirname(__FILE__) + '/../../lib/spark_api/cli/api_auth.rb'}"
-      end
-  
-      def self.setup_oauth2
-        " -r #{File.dirname(__FILE__) + '/../../lib/spark_api/cli/oauth2.rb'}"
-      end
-      
-      def self.export_env(options)
-        run_env = ""
-        OPTIONS_ENV.each do |k,v|
-          run_env << " #{v}=\"#{options[k]}\"" unless options[k].nil?
-        end
-        run_env
-      end
-      
-      private 
-      def self.parse_file_options(file)
-        yaml = SparkApi::Configuration::YamlConfig.new(file)
-        return {:oauth2 => yaml.oauth2}.merge(yaml.client_keys.merge(yaml.oauth2_keys))
-      end
-      
-      def self.version
-        "SparkApi v#{SparkApi::VERSION}"
-      end
-    end
-  end
-end

data/lib/spark_api/cli/api_auth.rb~

@@ -1,8 +0,0 @@
-require File.dirname(__FILE__) + "/../cli/setup"
-
-FlexmlsApi.configure do |config|
-  config.api_key = ENV["API_KEY"] 
-  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"]
-end

data/lib/spark_api/cli/oauth2.rb~

@@ -1,14 +0,0 @@
-require File.dirname(__FILE__) + "/../cli/setup"
-
-FlexmlsApi.configure do |config|
-  config.oauth2_provider = FlexmlsApi::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"]
-                          ) 
-  config.authentication_mode = FlexmlsApi::Authentication::OAuth2
-  config.endpoint = ENV["API_ENDPOINT"] if ENV["API_ENDPOINT"]
-end

data/lib/spark_api/cli/setup.rb~

@@ -1,47 +0,0 @@
-require "rubygems"
-require 'pp'
-require 'irb/ext/save-history'
-IRB.conf[:SAVE_HISTORY] = 1000
-IRB.conf[:HISTORY_FILE] = "#{ENV['HOME']}/.flexmls-api-history"
-
-if ENV["FLEXMLS_API_CONSOLE"].nil?
-  require 'flexmls_api'
-else
-  puts "Enabling console mode for local gem"
-  Bundler.require(:default, "development") if defined?(Bundler)
-  path = File.expand_path(File.dirname(__FILE__) + "/../../../lib/")
-  $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
-  require path + '/flexmls_api'
-end
-
-IRB.conf[:AUTO_INDENT]=true
-IRB.conf[:PROMPT][:FLEXMLS]= {
-  :PROMPT_I => "flexmlsApi:%03n:%i> ",
-  :PROMPT_S => "flexmlsApi:%03n:%i%l ",
-  :PROMPT_C => "flexmlsApi:%03n:%i* ",
-  :RETURN => "%s\n"
-} 
-
-IRB.conf[:PROMPT_MODE] = :FLEXMLS
-
-path = File.expand_path(File.dirname(__FILE__) + "/../../../lib/")
-$LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)
-require path + '/flexmls_api'
-
-module FlexmlsApi
-  def self.logger
-    if @logger.nil?
-      @logger = Logger.new(STDOUT)
-      @logger.level = ENV["DEBUG"].nil? ? Logger::WARN : Logger::DEBUG
-    end
-    @logger
-  end
-end
-
-FlexmlsApi.logger.info("Client configured!")
-
-include FlexmlsApi::Models
-
-def c
-  FlexmlsApi.client
-end

data/lib/spark_api/configuration.rb~

@@ -1,54 +0,0 @@
-module SparkApi
-  module Configuration
-    
-    # valid configuration options
-    VALID_OPTION_KEYS = [:api_key, :api_secret, :api_user, :endpoint, :user_agent, :version, :ssl, :oauth2_provider, :authentication_mode].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
-    ]
-      
-    require File.expand_path('../configuration/yaml', __FILE__)
-    
-    DEFAULT_API_KEY = nil
-    DEFAULT_API_SECRET = nil
-    DEFAULT_API_USER = nil
-    DEFAULT_ENDPOINT = 'https://api.sparkapi.com'
-    DEFAULT_VERSION = 'v1'
-    DEFAULT_USER_AGENT = "Spark API Ruby Gem #{VERSION}"
-    DEFAULT_SSL = true #false
-    DEFAULT_OAUTH2 = nil
-    
-    X_SPARK_API_USER_AGENT = "X-SparkApi-User-Agent"
-
-    attr_accessor *VALID_OPTION_KEYS
-    def configure
-      yield self
-    end
-
-    def self.extended(base)
-      base.reset_configuration
-    end
-
-    def options
-      VALID_OPTION_KEYS.inject({}) do |opt,key|
-        opt.merge(key => send(key))
-      end
-    end
-
-    def reset_configuration
-      self.api_key     = DEFAULT_API_KEY
-      self.api_secret  = DEFAULT_API_SECRET
-      self.api_user    = DEFAULT_API_USER
-      self.authentication_mode = SparkApi::Authentication::ApiAuth
-      self.endpoint    = DEFAULT_ENDPOINT
-      self.oauth2_provider = DEFAULT_OAUTH2
-      self.user_agent  = DEFAULT_USER_AGENT
-      self.ssl         = DEFAULT_SSL
-      self.version     = DEFAULT_VERSION
-      self
-    end
-  end
-end

data/lib/spark_api/configuration/yaml.rb~

@@ -1,101 +0,0 @@
-require 'erb'
-
-module FlexmlsApi
-  module Configuration
-    class YamlConfig
-      KEY_CONFIGURATIONS = VALID_OPTION_KEYS  + [:oauth2] + OAUTH2_KEYS  
-      DEFAULT_OAUTH2_PROVIDER = "FlexmlsApi::Authentication::OAuth2Impl::PasswordProvider"
-      attr_accessor *KEY_CONFIGURATIONS
-      attr_reader :client_keys, :oauth2_keys, :provider
-      
-      def initialize(filename=nil)
-        @oauth2 = false
-        load_file(filename) unless filename.nil?()
-      end
-      def load_file(file)
-        @file = file
-        @name = File.basename(file, ".yml")
-        config = YAML.load(ERB.new(File.read(file)).result)[api_env]
-        config["oauth2"] == true  ? load_oauth2(config) : load_api_auth(config)
-      rescue => e
-        FlexmlsApi.logger().error("Unable to load config file #{file}[#{api_env}]")
-        raise e
-      end
-      
-      def oauth2?
-        return oauth2 == true
-      end
-      
-      def name
-        @name
-      end
-      def api_env
-        current_env = "development"
-        if env.include?("FLEXMLS_API_ENV")
-          current_env = env["FLEXMLS_API_ENV"]
-        elsif env.include?("RAILS_ENV")
-          current_env = env["RAILS_ENV"]
-        end
-        return current_env
-      end
-      
-      # Used to specify the root of where to look for flexmlsApi config files
-      def self.config_path
-        path_prefix + "config/flexmls_api"
-      end
-      
-      def self.config_keys()
-        files = Dir["#{config_path}/*.yml"]
-        files.map {|f| File.basename(f,".yml") }
-      end
-      
-      def self.exists?(name)
-        File.exists? "#{config_path}/#{name}.yml"
-      end
-
-      def self.build(name)
-        yaml = YamlConfig.new("#{config_path}/#{name}.yml")
-      end
-      
-      protected
-      def env
-        ENV
-      end
-      
-      private 
-      def load_api_auth(config={})
-        @client_keys = {}
-        @oauth2_keys = {}
-        config.each do |key,val|
-          sym = key.to_sym
-          if VALID_OPTION_KEYS.include?(sym)
-            self.send("#{sym}=", val)
-            @client_keys[sym] = val
-          end
-        end
-      end
-      def load_oauth2(config={})
-        @oauth2_provider = DEFAULT_OAUTH2_PROVIDER
-        @client_keys = {:oauth2_provider => @oauth2_provider }
-        @oauth2_keys = {}
-        @oauth2 = true
-        config.each do |key,val|
-          sym = key.to_sym
-          if VALID_OPTION_KEYS.include?(sym)
-            self.send("#{sym}=", val)
-            @client_keys[sym] = val
-          elsif OAUTH2_KEYS.include? sym
-            self.send("#{sym}=", val)
-            @oauth2_keys[sym] = val
-          end
-        end
-      end
-      # In a rails app, default to the rails root, regardless of where that may be      
-      def self.path_prefix
-        "#{Rails.root}/"
-      rescue => e
-        ""
-      end
-    end
-  end
-end