flexmls_api 0.4.5 → 0.6.4

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

@@ -0,0 +1,85 @@
+module FlexmlsApi
+  module Authentication
+    module OAuth2Impl
+      class GrantTypeBase
+        GRANT_TYPES = [:authorization_code, :password, :refresh_token] 
+        
+        def self.create(client, provider, session=nil)
+          granter = nil
+          case provider.grant_type
+          when :authorization_code
+            granter = GrantTypeCode.new(client, provider, session)
+          when :password
+            granter = GrantTypePassword.new(client, provider, session)
+          # This method should only be used internally to the library
+          when :refresh_token
+            granter = GrantTypeRefresh.new(client, provider, session)
+          else
+            raise ClientError, "Unsupported grant type [#{provider.grant_type}]"
+          end
+          granter
+        end
+        
+        attr_reader :provider, :client, :session
+        def initialize(client, provider, session)
+          @client = client
+          @provider = provider
+          @session = session
+        end
+        def authenticate
+          
+        end
+        
+        def refresh
+          
+        end
+
+        protected
+
+        def create_session(token_params)
+          FlexmlsApi.logger.debug("Authenticating to #{provider.access_uri}")
+          uri = URI.parse(provider.access_uri)
+          request_path = "#{uri.path}"
+          response = oauth_access_connection("#{uri.scheme}://#{uri.host}").post(request_path, "#{token_params}").body
+          response.expires_in = provider.session_timeout if response.expires_in.nil?
+          response
+        end
+                
+        def needs_refreshing?
+          !@session.nil? && !@session.refresh_token.nil? && @session.expired?
+        end
+        
+        # Generate the appropriate request uri for authorizing this application for current user.
+        def authorization_url()
+          params = {
+            "client_id" => @provider.client_id,
+            "response_type" => "code",
+            "redirect_uri" => @provider.redirect_uri
+          }
+          "#{@provider.authorization_uri}?#{build_url_parameters(params)}"
+        end
+        
+        # Setup a faraday connection for dealing with an OAuth2 endpoint
+        def oauth_access_connection(endpoint)
+          opts = {
+            :headers => @client.headers
+          }
+          opts[:ssl] = {:verify => false }
+          opts[:url] = endpoint       
+          conn = Faraday::Connection.new(opts) do |builder|
+            builder.adapter Faraday.default_adapter
+            builder.use FlexmlsApi::Authentication::OAuth2Impl::Middleware
+          end
+        end        
+        def build_url_parameters(parameters={})
+          array = parameters.map do |key,value|
+            escaped_value = CGI.escape("#{value}")
+            "#{key}=#{escaped_value}"
+          end
+          array.join "&"
+        end
+      end
+      
+    end
+  end
+end

data/lib/flexmls_api/authentication/oauth2_impl/grant_type_code.rb

@@ -0,0 +1,48 @@
+
+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 web applications
+      # that have a OAuth flow for redirects.
+      class GrantTypeCode < GrantTypeBase
+        def initialize(client, provider, session)
+          super(client, provider, session)
+        end
+        def authenticate
+          if(provider.code.nil?)
+            FlexmlsApi.logger.debug("Redirecting to provider to get the authorization code")
+            provider.redirect(authorization_url)
+          end
+          if needs_refreshing?
+            new_session = refresh
+          end
+          return new_session unless new_session.nil?
+          create_session(token_params)
+        end
+        
+        def refresh()
+          refresher = GrantTypeRefresh.new(client,provider,session)
+          refresher.params = {"redirect_uri" => @provider.redirect_uri}
+          refresher.authenticate
+        rescue ClientError => e
+          FlexmlsApi.logger.info("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" => "authorization_code",
+            "code" => @provider.code,
+            "redirect_uri" => @provider.redirect_uri
+          }.to_json 
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/flexmls_api/authentication/oauth2_impl/grant_type_password.rb

@@ -0,0 +1,45 @@
+
+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("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/flexmls_api/authentication/oauth2_impl/grant_type_refresh.rb

@@ -0,0 +1,36 @@
+
+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("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/flexmls_api/authentication/oauth2_impl/middleware.rb

@@ -0,0 +1,39 @@
+
+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("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("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("Session= #{session.inspect}")
+          finished_env[:body] = session
+        end
+    
+        def initialize(app)
+          super(app)
+        end
+        
+      end
+    end
+  end
+end

data/lib/flexmls_api/cli.rb

@@ -0,0 +1,132 @@
+require 'optparse'
+
+module FlexmlsApi
+  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
+        :verbose => "VERBOSE",
+        :console => "FLEXMLS_API_CONSOLE"  # not a public option, meant to distinguish bin/flexmls_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 flexmls_api gem..."
+        exec "#{cmd}"
+      end
+      
+      def self.irb()
+        RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+      end
+      
+      private
+      def self.setup_options(stdout,arguments)
+        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]]
+        }
+        
+        parser = OptionParser.new do |opts|
+          opts.banner = <<-BANNER.gsub(/^          /,'')
+            FlexmlsApi 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 flexmls API authentication mode for access. ",
+                  "See http://www.flexmls.com/developers/api/api-services/authentication/ for more information on authentication types.",
+                  "Default: false") { |arg| options[:oauth2] = arg }
+          opts.on("-e","--endpoint",
+                  "URI of the API.",
+                  "Default: ENV['#{OPTIONS_ENV[:endpoint]}']") { |arg| options[:endpoint] = arg }
+
+          # OAUTH2
+          opts.on("--client_id",
+                  "OAuth2 client id",
+                  "Default: ENV['#{OPTIONS_ENV[:client_id]}']") { |arg| options[:client_id] = arg }
+          opts.on("--client_secret",
+                  "OAuth2 client secret",
+                  "Default: ENV['#{OPTIONS_ENV[:client_secret]}']") { |arg| options[:client_secret] = arg }
+          opts.on("-u","--username",
+                  "OAuth2 username",
+                  "Default: ENV['#{OPTIONS_ENV[:username]}']") { |arg| options[:username] = arg }
+          opts.on("-p","--password",
+                  "OAuth2 password",
+                  "Default: ENV['#{OPTIONS_ENV[:password]}']") { |arg| options[:password] = arg }
+          opts.on("--access_uri",
+                  "OAuth2 path for granting access to the application",
+                  "Default: ENV['#{OPTIONS_ENV[:access_uri]}']") { |arg| options[:access_uri] = arg }
+                    
+          # API AUTH
+          opts.on("--api_key",
+                  "Authentication key for running the api using the default api authentication",
+                  "Default: ENV['#{OPTIONS_ENV[:api_key]}']") { |arg| options[:api_key] = arg }
+          opts.on("--api_secret",
+                  "API secret for the api key",
+                   "Default: ENV['#{OPTIONS_ENV[:api_secret]}']") { |arg| options[:api_secret] = arg }
+          opts.on("--api_user",
+                  "ID of the flexmls user to run the client as.",
+                  "Default: ENV['#{OPTIONS_ENV[:api_user]}']") { |arg| options[:api_user] = arg }
+                    
+          opts.on("-v", "--verbose",
+                  "Show detailed request logging information.") { |arg| options[:verbose] = arg }
+          opts.on("-h", "--help",
+                  "Show this help message.") { stdout.puts opts; exit }
+          opts.parse!(arguments)
+        
+        end
+        
+        return options
+      end
+      
+      def self.setup_api_auth
+        " -r #{File.dirname(__FILE__) + '/../../lib/flexmls_api/cli/api_auth.rb'}"
+      end
+  
+      def self.setup_oauth2
+        " -r #{File.dirname(__FILE__) + '/../../lib/flexmls_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
+    end
+  end
+end

data/lib/flexmls_api/cli/api_auth.rb

@@ -0,0 +1,8 @@
+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/flexmls_api/cli/oauth2.rb

@@ -0,0 +1,43 @@
+require File.dirname(__FILE__) + "/../cli/setup"
+
+class CLIOAuth2Provider < FlexmlsApi::Authentication::BaseOAuth2Provider
+  def initialize(credentials)
+    @authorization_uri = credentials[:authorization_uri]
+    @access_uri        = credentials[:access_uri]
+    @redirect_uri      = credentials[:redirect_uri]
+    @client_id         = credentials[:client_id]
+    @client_secret     = credentials[:client_secret]
+    @username          = credentials[:username]
+    @password          = credentials[:password]
+    @session           = nil
+  end
+
+  def grant_type
+    :password
+  end
+  
+  def load_session()
+    @session
+  end
+
+  def save_session(session)
+    @session = session
+  end
+
+  def destroy_session
+    @session = nil
+  end
+end
+
+FlexmlsApi.configure do |config|
+  config.oauth2_provider = CLIOAuth2Provider.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