attune 1.0.3 → 1.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3bcafd086e89663973f17106d28c4a1b198c32bf
-  data.tar.gz: 6321361a8d4d7b362d117810745ac2d1898959d8
+  metadata.gz: eb1defe49351ac0ececcbee2e6234ecd06dd923e
+  data.tar.gz: f5d0b12d7b5f6514847b2de1bcd07977b1b6acfb
 SHA512:
-  metadata.gz: 19d522512f5bfe0458c0f3e8abf15a130920c0d1934e40c59bd0116c380813dc17db49c79fcbd15960364c07b65b10f5092aafbdd8377c2f9284d6d078dbb109
-  data.tar.gz: 84564a663fd330b4d94bad07bd32410725baab5da48dfa259dc44509d6c11968911e288c21fdb7019f658006f3d5f45b33aada520e58eea3001cd58d3bd53e86
+  metadata.gz: 0251f285edcf9c2e759928f87ac2407e2e6cd274ee71bceda05b959a87a64eb26a7eadce39744fc5fc8c0c60d654d2b4cae3a1d222d8bffcc7e514cde8afb79c
+  data.tar.gz: 07d2c0d9cae0cecf2158438e9597832c0fcad15f9e1f455cefde22bde4f2dbf81aa73d14d4f32c4f40cce1ab119f5897a8d9950e7f0c17126f7ee218f1492e36

data/README.md

@@ -2,9 +2,9 @@
 
 A client for the [Attune ranking API](http://attune.co/). Built using the excellent [faraday](https://github.com/lostisland/faraday) library.
 
-* [Github](https://github.com/DigitalStripe/attune-ruby)
+* [Github](https://github.com/attune-api/attune-ruby)
 * [RubyGems](https://rubygems.org/gems/attune)
-* [Documentation](http://rdoc.info/github/DigitalStripe/attune-ruby)
+* [Documentation](http://rdoc.info/github/attune-api/attune-ruby)
 
 ## Installation
 
@@ -103,9 +103,9 @@ client = Attune::Client.new(auth_token: "my-secure-auth-token", timeout: 2)
 ```
 
 See the documentation for
-[Attune::Configurable](http://rdoc.info/github/DigitalStripe/attune-ruby/master/Attune/Configurable)
+[Attune::Configurable](http://rdoc.info/github/attune-api/attune-ruby/master/Attune/Configurable)
 and the
-[default configuration](http://rdoc.info/github/DigitalStripe/attune-ruby/master/Attune/Default)
+[default configuration](http://rdoc.info/github/attune-api/attune-ruby/master/Attune/Default)
 for more details.
 
 ### Testing
@@ -121,7 +121,7 @@ Calling `.test_mode!` is equivalent to setting `disabled` to true and `exception
 
 ## Contributing
 
-1. Fork it ( http://github.com/DigitalStripe/attune/fork )
+1. Fork it ( http://github.com/attune-api/attune-ruby/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/attune.gemspec

@@ -6,11 +6,11 @@ require 'attune/version'
 Gem::Specification.new do |spec|
   spec.name          = "attune"
   spec.version       = Attune::VERSION
-  spec.authors       = ["John Hawthorn"]
-  spec.email         = ["john@freerunningtechnologies.com"]
+  spec.authors       = ["John Hawthorn", "Jason Gritman"]
+  spec.email         = ["john@freerunningtechnologies.com", "jason@attune.co"]
   spec.summary       = %q{Client for the Attune product ranking API.}
   spec.description   = %q{Client for the Attune product ranking API.}
-  spec.homepage      = "https://github.com/DigitalStripe/attune-ruby"
+  spec.homepage      = "https://github.com/attune-api/attune-ruby"
   spec.license       = "MIT"
 
   spec.files         = `git ls-files`.split($/)

data/lib/attune.rb

@@ -4,6 +4,19 @@ require "attune/version"
 require "attune/configurable"
 require "attune/default"
 require "attune/client"
+require "attune/api/entities"
+require "attune/api/anonymous"
+require "attune/models/blacklistgetresponse"
+require "attune/models/anonymousresult"
+require "attune/models/blacklistparams"
+require "attune/models/rankedentities"
+require "attune/models/rankingparams"
+require "attune/models/customer"
+require "attune/models/blacklist"
+require "attune/models/batchrankingrequest"
+require "attune/models/scopeentry"
+require "attune/models/blacklistsaveresponse"
+require "attune/models/batchrankingresult"
 
 module Attune
   def self.client
@@ -23,3 +36,4 @@ module Attune
     Default.configure(&block)
   end
 end
+

data/lib/attune/api/anonymous.rb

@@ -0,0 +1,131 @@
+require "json"
+require "uri"
+
+module Attune
+  module Api
+    class Anonymous
+      basePath = "/"
+
+      def initialize(client)
+        @client = client
+      end
+
+      def escapeString(string)
+        URI.encode(string.to_s)
+      end
+
+      # Creates an anonymous visitor.
+      #
+      # @return [Attune::Model::AnonymousResult]
+      # @raise [ArgumentError] if user_agent is not provided
+      # @raise [Faraday::Error::ClientError] if the request fails or exceeds the timeout
+      # @raise [AuthenticationException] if authorization header not accepted
+      def create ()
+        query_param_keys = []
+
+        # set default values and merge with input
+        options = {
+        }
+
+        #resource path
+        path = "/anonymous".sub('{format}','json')
+
+        # pull querystring keys from options
+        queryopts = options.select do |key,value|
+          query_param_keys.include? key
+        end
+
+        headers = nil
+        post_body = nil
+        response = @client.request(:POST, path, {:params=>queryopts,:headers=>headers, :body=>post_body })
+        Attune::Model::AnonymousResult.new(JSON.parse(response.body))
+      end
+      
+      # Binds one actor to another, allowing activities of those actors to be shared between the two.
+      #
+      # @param [string] anonymous
+      # @param [Customer] body
+      # @raise [ArgumentError] if user_agent is not provided
+      # @raise [Faraday::Error::ClientError] if the request fails or exceeds the timeout
+      # @raise [AuthenticationException] if authorization header not accepted
+      def update (anonymous,body)
+        query_param_keys = []
+
+        # verify existence of params
+        raise "anonymous is required" if anonymous.nil?
+        raise "body is required" if body.nil?
+        # set default values and merge with input
+        options = {
+        :anonymous => anonymous,
+          :body => body}
+
+        #resource path
+        path = "/anonymous/{anonymous}".sub('{format}','json').sub('{' + 'anonymous' + '}', escapeString(anonymous))
+        
+
+        # pull querystring keys from options
+        queryopts = options.select do |key,value|
+          query_param_keys.include? key
+        end
+
+        headers = nil
+        post_body = nil
+        if body != nil
+          if body.is_a?(Array)
+            array = Array.new
+            body.each do |item|
+              if item.respond_to?("to_body".to_sym)
+                array.push item.to_body
+              else
+                array.push item
+              end
+            end
+            post_body = array
+
+          else
+            if body.respond_to?("to_body".to_sym)
+    	        post_body = body.to_body
+    	      else
+    	        post_body = body
+    	      end
+          end
+        end
+        @client.request(:PUT, path, {:params=>queryopts,:headers=>headers, :body=>post_body})
+        
+      end
+      
+      # get
+      #
+      # @param [string] anonymous
+      # @return [Attune::Model::Customer]
+      # @raise [ArgumentError] if user_agent is not provided
+      # @raise [Faraday::Error::ClientError] if the request fails or exceeds the timeout
+      # @raise [AuthenticationException] if authorization header not accepted
+      def get (anonymous)
+        query_param_keys = []
+
+        # verify existence of params
+        raise "anonymous is required" if anonymous.nil?
+        # set default values and merge with input
+        options = {
+        :anonymous => anonymous}
+
+        #resource path
+        path = "/anonymous/{anonymous}".sub('{format}','json').sub('{' + 'anonymous' + '}', escapeString(anonymous))
+        
+
+        # pull querystring keys from options
+        queryopts = options.select do |key,value|
+          query_param_keys.include? key
+        end
+
+        headers = nil
+        post_body = nil
+        response = @client.request(:GET, path, {:params=>queryopts,:headers=>headers, :body=>post_body })
+        Attune::Model::Customer.new(JSON.parse(response.body))
+      end
+      
+      end
+  end
+end
+

data/lib/attune/api/entities.rb

@@ -0,0 +1,195 @@
+require "json"
+require "uri"
+
+module Attune
+  module Api
+    class Entities
+      basePath = "/"
+
+      def initialize(client)
+        @client = client
+      end
+
+      def escapeString(string)
+        URI.encode(string.to_s)
+      end
+
+      # blacklistGet
+      #
+      # @return [Attune::Model::BlacklistGetResponse]
+      # @raise [ArgumentError] if user_agent is not provided
+      # @raise [Faraday::Error::ClientError] if the request fails or exceeds the timeout
+      # @raise [AuthenticationException] if authorization header not accepted
+      def blacklist_get ()
+        query_param_keys = []
+
+        # set default values and merge with input
+        options = {
+        }
+
+        #resource path
+        path = "/entities/rankings/blacklists".sub('{format}','json')
+
+        # pull querystring keys from options
+        queryopts = options.select do |key,value|
+          query_param_keys.include? key
+        end
+
+        headers = nil
+        post_body = nil
+        response = @client.request(:GET, path, {:params=>queryopts,:headers=>headers, :body=>post_body })
+        Attune::Model::BlacklistGetResponse.new(JSON.parse(response.body))
+      end
+      
+      # blacklistSave
+      #
+      # @param [BlacklistParams] body
+      # @return [Attune::Model::BlacklistSaveResponse]
+      # @raise [ArgumentError] if user_agent is not provided
+      # @raise [Faraday::Error::ClientError] if the request fails or exceeds the timeout
+      # @raise [AuthenticationException] if authorization header not accepted
+      def blacklist_save (body)
+        query_param_keys = []
+
+        # set default values and merge with input
+        options = {
+        :body => body}
+
+        #resource path
+        path = "/entities/rankings/blacklists".sub('{format}','json')
+
+        # pull querystring keys from options
+        queryopts = options.select do |key,value|
+          query_param_keys.include? key
+        end
+
+        headers = nil
+        post_body = nil
+        if body != nil
+          if body.is_a?(Array)
+            array = Array.new
+            body.each do |item|
+              if item.respond_to?("to_body".to_sym)
+                array.push item.to_body
+              else
+                array.push item
+              end
+            end
+            post_body = array
+
+          else
+            if body.respond_to?("to_body".to_sym)
+    	        post_body = body.to_body
+    	      else
+    	        post_body = body
+    	      end
+          end
+        end
+        response = @client.request(:POST, path, {:params=>queryopts,:headers=>headers, :body=>post_body })
+        Attune::Model::BlacklistSaveResponse.new(JSON.parse(response.body))
+      end
+      
+      # getRankings
+      #
+      # @param [RankingParams] body
+      # @return [Attune::Model::RankedEntities]
+      # @raise [ArgumentError] if user_agent is not provided
+      # @raise [Faraday::Error::ClientError] if the request fails or exceeds the timeout
+      # @raise [AuthenticationException] if authorization header not accepted
+      def get_rankings (body)
+        query_param_keys = []
+
+        # verify existence of params
+        raise "body is required" if body.nil?
+        # set default values and merge with input
+        options = {
+        :body => body}
+
+        #resource path
+        path = "/entities/ranking".sub('{format}','json')
+
+        # pull querystring keys from options
+        queryopts = options.select do |key,value|
+          query_param_keys.include? key
+        end
+
+        headers = nil
+        post_body = nil
+        if body != nil
+          if body.is_a?(Array)
+            array = Array.new
+            body.each do |item|
+              if item.respond_to?("to_body".to_sym)
+                array.push item.to_body
+              else
+                array.push item
+              end
+            end
+            post_body = array
+
+          else
+            if body.respond_to?("to_body".to_sym)
+    	        post_body = body.to_body
+    	      else
+    	        post_body = body
+    	      end
+          end
+        end
+        response = @client.request(:POST, path, {:params=>queryopts,:headers=>headers, :body=>post_body })
+        Attune::Model::RankedEntities.new(JSON.parse(response.body))
+      end
+      
+      # batchGetRankings
+      #
+      # @param [BatchRankingRequest] body
+      # @return [Attune::Model::BatchRankingResult]
+      # @raise [ArgumentError] if user_agent is not provided
+      # @raise [Faraday::Error::ClientError] if the request fails or exceeds the timeout
+      # @raise [AuthenticationException] if authorization header not accepted
+      def batch_get_rankings (body)
+        query_param_keys = []
+
+        # verify existence of params
+        raise "body is required" if body.nil?
+        # set default values and merge with input
+        options = {
+        :body => body}
+
+        #resource path
+        path = "/entities/ranking/many".sub('{format}','json')
+
+        # pull querystring keys from options
+        queryopts = options.select do |key,value|
+          query_param_keys.include? key
+        end
+
+        headers = nil
+        post_body = nil
+        if body != nil
+          if body.is_a?(Array)
+            array = Array.new
+            body.each do |item|
+              if item.respond_to?("to_body".to_sym)
+                array.push item.to_body
+              else
+                array.push item
+              end
+            end
+            post_body = array
+
+          else
+            if body.respond_to?("to_body".to_sym)
+    	        post_body = body.to_body
+    	      else
+    	        post_body = body
+    	      end
+          end
+        end
+        response = @client.request(:POST, path, {:params=>queryopts,:headers=>headers, :body=>post_body })
+        Attune::Model::BatchRankingResult.new(JSON.parse(response.body))
+      end
+      
+      end
+  end
+end
+

data/lib/attune/call_dropping.rb

@@ -50,3 +50,4 @@ module Attune
     end
   end
 end
+

data/lib/attune/client.rb

@@ -15,7 +15,8 @@ module Attune
 
   class Client
     include Attune::Configurable
-
+    attr_reader :entities
+    attr_reader :anonymous
     # Initializes a new Client
     #
     # @example
@@ -30,7 +31,9 @@ module Attune
       Attune::Configurable::KEYS.each do |key|
         send("#{key}=", options[key] || Attune::Default.send(key))
       end
-    end
+      @entities = Attune::Api::Entities.new(self)
+      @anonymous = Attune::Api::Anonymous.new(self)
+      end
 
     # Request an auth token
     #
@@ -46,11 +49,10 @@ module Attune
       raise ArgumentError, "client_id required" unless client_id
       raise ArgumentError, "client_secret required" unless client_secret
 
-      response = post_form("oauth/token",
-        client_id: client_id,
-        client_secret: client_secret,
-        grant_type: :client_credentials
-      )
+      params =  {client_id: client_id,
+          client_secret: client_secret,
+          grant_type: :client_credentials}
+      response = post_form("oauth/token", params)
       if response
         body = JSON.parse(response.body)
         if body['error']
@@ -63,160 +65,17 @@ module Attune
       end
     end
 
-    # Create an anonymous tracked user
-    #
-    # @example Generate a new id (preferred)
-    #   anonymous_id = client.create_anonymous(
-    #     user_agent: 'Mozilla/5.0'
-    #   )
-    # @example Create using an existing id
-    #   client.create_anonymous(
-    #     id: '0cddbc0-6114-11e3-949a-0800200c9a66',
-    #     user_agent: 'Mozilla/5.0'
-    #   )
-    # @param [Hash] options
-    # @option options [String] :id optional. An id will be generated if this is not provided
-    # @option options [String] :user_agent The user agent for the application used by the anonymous users
-    # @return id [String]
-    # @raise [ArgumentError] if user_agent is not provided
-    # @raise [Faraday::Error::ClientError] if the request fails or exceeds the timeout
-    # @raise [AuthenticationException] if authorization header not accepted
-    def create_anonymous(options)
-      raise ArgumentError, "user_agent required" unless options[:user_agent]
-      if id = options[:id]
-        put("anonymous/#{id}", {user_agent: options[:user_agent]})
-        id
-      else
-        if response = post_json("anonymous", {user_agent: options[:user_agent]})
-          response[:location][/\Aurn:id:([a-z0-9\-]+)\Z/, 1]
-        else
-          # Return a new UUID if there was an exception and we're in mock mode
-          SecureRandom.uuid
-        end
-      end
-    end
-
-    # Returns all entities from the specified collection in order of the user's preference
-    #
-    # @example
-    #   rankings = client.get_rankings(
-    #     id: '0cddbc0-6114-11e3-949a-0800200c9a66',
-    #     view: 'b/mens-pants',
-    #     collection: 'products',
-    #     entities: %w[1001, 1002, 1003, 1004]
-    #   )
-    # @param [Hash] options
-    # @option options [String] :id The anonymous user id for whom to grab rankings
-    # @option options [String] :view The page or app URN on which the entities will be displayed
-    # @option options [String] :collection name of the collection of entities
-    # @option options [Array<String>] :entities entities to be ranked. These should be numeric strings or integers.
-    # @option options [String] :ip ip address of remote user. Used for geolocation (optional)
-    # @option options [String] :customer id of customer (optional)
-    # @return [Hash{Symbol => Hash, Array<String>}]
-    #   * :headers the attune headers indicating ranking performed
-    #   * :entities entities in their ranked order
-    # @raise [ArgumentError] if required parameters are missing
-    # @raise [Faraday::Error::ClientError] if the request fails or exceeds the timeout
-    # @raise [AuthenticationException] if authorization header not accepted
-    def get_rankings(options)
-      qs = encoded_ranking_params(options)
-      rankings = {}
-      if response = get("rankings/#{qs}", customer: options.fetch(:customer, 'none'))
-        rankings[:headers] = response.headers.select { |k,v| k =~ /^attune/ }
-        rankings[:entities] = JSON.parse(response.body)['ranking']
-      else
-        # In mock mode: return the entities in the order passed in
-        rankings[:headers] = {"attune-cell"=>"mock", "attune-ranking"=>"mock"}
-        rankings[:entities] = options[:entities].map(&:to_s)
-      end
-      rankings
-    end
-
-    # Get multiple rankings in one call
-    #
-    # @example
-    #   rankings = client.multi_get_rankings([
-    #     {
-    #       id: '0cddbc0-6114-11e3-949a-0800200c9a66',
-    #       view: 'b/mens-pants',
-    #       collection: 'products',
-    #       entities: %w[1001, 1002, 1003, 1004]
-    #     },
-    #     {
-    #       id: '0cddbc0-6114-11e3-949a-0800200c9a66',
-    #       view: 'b/mens-pants',
-    #       collection: 'products',
-    #       entities: %w[2001, 2002, 2003, 2004]
-    #     }
-    #   ])
-    # @param [Array<Hash>] multi_options An array of options (see #get_rankings)
-    # @return [Hash{Symbol => Hash, Array<Array<String>>}]
-    #   * :headers the attune headers indicating ranking performed
-    #   * :entities entities in their ranked order
-    # @raise [Faraday::Error::ClientError] if the request fails or exceeds the timeout
-    # @raise [AuthenticationException] if authorization header not accepted
-    def multi_get_rankings(multi_options)
-      requests = multi_options.map do |options|
-        encoded_ranking_params(options)
-      end
-      rankings = {}
-      if response = get("rankings", ids: requests)
-        results = JSON.parse(response.body)['results']
-        rankings[:headers] = response.headers.select { |k,v| k =~ /^attune/ }
-
-        # Order of encoded paramaters may change, so we must parse them
-        results = Hash[results.map do |request, result|
-          [CGI.parse(request), result]
-        end]
-        rankings[:entities] = requests.map do |request|
-          results[CGI.parse(request)]['ranking']
-        end
-      else
-        # In mock mode: return the entities in the order passed in
-        rankings[:headers] = {"attune-cell"=>"mock", "attune-ranking"=>"mock"}
-        rankings[:entities] = multi_options.map do |options|
-          options[:entities].map(&:to_s)
-        end
+    def request(http_method, path, opts)
+      adapter_method = adapter.method(http_method.downcase)
+      headers = {'Content-Type' => 'application/json' }
+      headers.merge! opts[:headers] if opts[:headers]
+      adapter_method.call do |req|
+        req.url path
+        req.headers['Content-Type'] = 'application/json'
+        req.headers.merge! opts[:headers] if opts[:headers]
+        req.params = opts[:params] if opts[:params]
+        req.body = ::JSON.dump(opts[:body]) if opts[:body]
       end
-      rankings
-    end
-
-    # Binds an anonymous user to a customer id
-    #
-    # @param [String] id The anonymous visitor to bind
-    # @param [String] customer_id The customer id to bind
-    # @example
-    #   rankings = client.bind(
-    #     '25892e17-80f6-415f-9c65-7395632f022',
-    #     'cd171f7c-560d-4a62-8d65-16b87419a58'
-    #   )
-    # @raise [Faraday::Error::ClientError] if the request fails or exceeds the timeout
-    # @raise [AuthenticationException] if authorization header not accepted
-    def bind(id, customer_id)
-      put("bindings/anonymous=#{id}&customer=#{customer_id}")
-      true
-    end
-
-    private
-    def encoded_ranking_params(options)
-      params = {
-        anonymous: options.fetch(:id),
-        entities: options.fetch(:entities).join(','),
-        entity_collection: options.fetch(:collection),
-        ip: options.fetch(:ip, 'none'),
-        view: options.fetch(:view)
-      }
-      Faraday::Utils::ParamsHash[params].to_query
-    end
-
-    def get(path, params={})
-      adapter.get(path, params)
-    rescue Errno::ENOENT, Faraday::Error::ClientError => e
-      handle_exception(e)
-    end
-
-    def put(path, params={})
-      adapter.put(path, ::JSON.dump(params))
     rescue Errno::ENOENT, Faraday::Error::ClientError => e
       handle_exception(e)
     end
@@ -227,16 +86,6 @@ module Attune
       handle_exception(e)
     end
 
-    def post_json(path, params={})
-      adapter.post do |req|
-        req.url path
-        req.headers['Content-Type'] = 'application/json'
-        req.body = ::JSON.dump(params)
-      end
-    rescue Errno::ENOENT, Faraday::Error::ClientError => e
-      handle_exception(e)
-    end
-
     def handle_exception e
       if exception_handler == :mock
         nil
@@ -259,3 +108,4 @@ module Attune
     end
   end
 end
+