attune 1.0.9 → 1.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 33e278960925d8b1aeb5e7575b66a575299e6323
-  data.tar.gz: 614890038d5ff2ab7ad3d21517c08fa6bea7df01
+  metadata.gz: a4ef474d66c59fbfb92d08ebdc534457aaebd661
+  data.tar.gz: 2fd75bc17a939aa0fd00f738d253109977867e2c
 SHA512:
-  metadata.gz: 1be52d8cb15c9822985205f2824997e2de1c5e60e00e192d54deaa7243568205f894acc8880f6f9598d9b57b2746f70bf158023518b79d2d11a136e0f33083fc
-  data.tar.gz: 6b60a69e5a43cd521fafe45a5dda7cedcd55fb468ea891a54f37a63bd9ec3dc3de0f34813a4a6f1eccea6e2fcf0830be8cfeea97dad09d7a4e95786e4d6a7e65
+  metadata.gz: 50bbc9485525130501fe6662d724533103547c259d4fce88b2e9734237eb99997fa1d8fb01506a16851c81a58d15d620678fe7269dc818e1db79f7c52bb5b696
+  data.tar.gz: de04269263f15ef7e26d32cb15884c867a7a74641e15bd9af65bb835676ff5667dc8db9ea916c3c7f7df11b1a7f9eb5e6a7dc60687aa23eea68e2c3015e7d9e0

data/lib/attune.rb

@@ -13,10 +13,12 @@ require "attune/models/blacklist_params"
 require "attune/models/ranked_entities"
 require "attune/models/ranking_params"
 require "attune/models/customer"
+require "attune/models/blacklist_update_response"
 require "attune/models/blacklist"
 require "attune/models/batch_ranking_request"
 require "attune/models/scope_entry"
 require "attune/models/blacklist_save_response"
+require "attune/models/blacklist_delete_response"
 require "attune/models/batch_ranking_result"
 
 module Attune

data/lib/attune/api/anonymous.rb

@@ -48,21 +48,23 @@ module Attune
         
       end
       
-      # Returns an anonymous visitor, containing any assigned customer ID.
+      # Binds one actor to another, allowing activities of those actors to be shared between the two.
       #
       # @param [String] anonymous
-      # @return [Attune::Model::Customer]
+      # @param [Attune::Model::Customer] body
       # @raise [ArgumentError] for invalid inputs
       # @raise [Faraday::Error::ClientError] if the request fails or exceeds the timeout
       # @raise [AuthenticationException] if authorization header not accepted
-      def get (anonymous)
+      def update (anonymous,body)
         query_param_keys = []
 
         # verify existence of params
         raise ArgumentError, "anonymous is required" if anonymous.nil?
+        raise ArgumentError, "body is required" if body.nil?
         # set default values and merge with input
         options = {
-        :anonymous => anonymous}
+        :anonymous => anonymous,
+          :body => body}
 
         #resource path
         path = "/anonymous/{anonymous}".sub('{format}','json').sub('{' + 'anonymous' + '}', escapeString(anonymous))
@@ -75,38 +77,45 @@ module Attune
 
         headers = nil
         post_body = nil
-        response = @client.request(:GET, path, {:params=>queryopts,:headers=>headers, :body=>post_body })
-        if response
-          Attune::Model::Customer.new(JSON.parse(response.body))
-        else
-          mockProc = MOCKS['Anonymous.get']
-          if mockProc
-            mockResponse = mockProc.call(anonymous)
-            Attune::Model::Customer.new(mockResponse)
+        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
-            nil
+            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
       
-      # Binds one actor to another, allowing activities of those actors to be shared between the two.
+      # Returns an anonymous visitor, containing any assigned customer ID.
       #
       # @param [String] anonymous
-      # @param [Attune::Model::Customer] body
+      # @return [Attune::Model::Customer]
       # @raise [ArgumentError] for invalid inputs
       # @raise [Faraday::Error::ClientError] if the request fails or exceeds the timeout
       # @raise [AuthenticationException] if authorization header not accepted
-      def update (anonymous,body)
+      def get (anonymous)
         query_param_keys = []
 
         # verify existence of params
         raise ArgumentError, "anonymous is required" if anonymous.nil?
-        raise ArgumentError, "body is required" if body.nil?
         # set default values and merge with input
         options = {
-        :anonymous => anonymous,
-          :body => body}
+        :anonymous => anonymous}
 
         #resource path
         path = "/anonymous/{anonymous}".sub('{format}','json').sub('{' + 'anonymous' + '}', escapeString(anonymous))
@@ -119,27 +128,18 @@ module Attune
 
         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
-
+        response = @client.request(:GET, path, {:params=>queryopts,:headers=>headers, :body=>post_body })
+        if response
+          Attune::Model::Customer.new(JSON.parse(response.body))
+        else
+          mockProc = MOCKS['Anonymous.get']
+          if mockProc
+            mockResponse = mockProc.call(anonymous)
+            Attune::Model::Customer.new(mockResponse)
           else
-            if body.respond_to?("to_body".to_sym)
-              post_body = body.to_body
-            else
-              post_body = body
-            end
+            nil
           end
         end
-        @client.request(:PUT, path, {:params=>queryopts,:headers=>headers, :body=>post_body})
         
       end
       

data/lib/attune/api/entities.rb

@@ -10,13 +10,72 @@ module Attune
         @client = client
       end
 
+      # Save a new blacklist entry.
+      #
+      # @param [Attune::Model::BlacklistParams] body
+      # @return [Attune::Model::BlacklistSaveResponse]
+      # @raise [ArgumentError] for invalid inputs
+      # @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 })
+        if response
+          Attune::Model::BlacklistSaveResponse.new(JSON.parse(response.body))
+        else
+          mockProc = MOCKS['Entities.blacklist_save']
+          if mockProc
+            mockResponse = mockProc.call(body)
+            Attune::Model::BlacklistSaveResponse.new(mockResponse)
+          else
+            nil
+          end
+        end
+        
+      end
+      
       # List all blacklist entries for your account.
       #
       # @return [Attune::Model::BlacklistGetResponse]
       # @raise [ArgumentError] for invalid inputs
       # @raise [Faraday::Error::ClientError] if the request fails or exceeds the timeout
       # @raise [AuthenticationException] if authorization header not accepted
-      def blacklist_get ()
+      def blacklist_get_all ()
         query_param_keys = []
 
         # set default values and merge with input
@@ -37,7 +96,7 @@ module Attune
         if response
           Attune::Model::BlacklistGetResponse.new(JSON.parse(response.body))
         else
-          mockProc = MOCKS['Entities.blacklist_get']
+          mockProc = MOCKS['Entities.blacklist_get_all']
           if mockProc
             mockResponse = mockProc.call()
             Attune::Model::BlacklistGetResponse.new(mockResponse)
@@ -48,22 +107,27 @@ module Attune
         
       end
       
-      # Save a new blacklist entry.
+      # Updates a blacklist with the specified ID.
       #
+      # @param [String] id
       # @param [Attune::Model::BlacklistParams] body
-      # @return [Attune::Model::BlacklistSaveResponse]
+      # @return [Attune::Model::BlacklistUpdateResponse]
       # @raise [ArgumentError] for invalid inputs
       # @raise [Faraday::Error::ClientError] if the request fails or exceeds the timeout
       # @raise [AuthenticationException] if authorization header not accepted
-      def blacklist_save (body)
+      def blacklist_update (id,body)
         query_param_keys = []
 
+        # verify existence of params
+        raise ArgumentError, "id is required" if id.nil?
         # set default values and merge with input
         options = {
-        :body => body}
+        :id => id,
+          :body => body}
 
         #resource path
-        path = "/entities/rankings/blacklists".sub('{format}','json')
+        path = "/entities/rankings/blacklists/{id}".sub('{format}','json').sub('{' + 'id' + '}', escapeString(id))
+        
 
         # pull querystring keys from options
         queryopts = options.select do |key,value|
@@ -92,14 +156,98 @@ module Attune
             end
           end
         end
-        response = @client.request(:POST, path, {:params=>queryopts,:headers=>headers, :body=>post_body })
+        response = @client.request(:PUT, path, {:params=>queryopts,:headers=>headers, :body=>post_body })
         if response
-          Attune::Model::BlacklistSaveResponse.new(JSON.parse(response.body))
+          Attune::Model::BlacklistUpdateResponse.new(JSON.parse(response.body))
         else
-          mockProc = MOCKS['Entities.blacklist_save']
+          mockProc = MOCKS['Entities.blacklist_update']
           if mockProc
-            mockResponse = mockProc.call(body)
-            Attune::Model::BlacklistSaveResponse.new(mockResponse)
+            mockResponse = mockProc.call(id,body)
+            Attune::Model::BlacklistUpdateResponse.new(mockResponse)
+          else
+            nil
+          end
+        end
+        
+      end
+      
+      # Delete blacklist by id.
+      #
+      # @param [String] id
+      # @return [Attune::Model::BlacklistDeleteResponse]
+      # @raise [ArgumentError] for invalid inputs
+      # @raise [Faraday::Error::ClientError] if the request fails or exceeds the timeout
+      # @raise [AuthenticationException] if authorization header not accepted
+      def blacklist_delete (id)
+        query_param_keys = []
+
+        # verify existence of params
+        raise ArgumentError, "id is required" if id.nil?
+        # set default values and merge with input
+        options = {
+        :id => id}
+
+        #resource path
+        path = "/entities/rankings/blacklists/{id}".sub('{format}','json').sub('{' + 'id' + '}', escapeString(id))
+        
+
+        # 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(:DELETE, path, {:params=>queryopts,:headers=>headers, :body=>post_body })
+        if response
+          Attune::Model::BlacklistDeleteResponse.new(JSON.parse(response.body))
+        else
+          mockProc = MOCKS['Entities.blacklist_delete']
+          if mockProc
+            mockResponse = mockProc.call(id)
+            Attune::Model::BlacklistDeleteResponse.new(mockResponse)
+          else
+            nil
+          end
+        end
+        
+      end
+      
+      # Returns the blacklist with the specified ID.
+      #
+      # @param [String] id
+      # @return [Attune::Model::Blacklist]
+      # @raise [ArgumentError] for invalid inputs
+      # @raise [Faraday::Error::ClientError] if the request fails or exceeds the timeout
+      # @raise [AuthenticationException] if authorization header not accepted
+      def blacklist_get (id)
+        query_param_keys = []
+
+        # verify existence of params
+        raise ArgumentError, "id is required" if id.nil?
+        # set default values and merge with input
+        options = {
+        :id => id}
+
+        #resource path
+        path = "/entities/rankings/blacklists/{id}".sub('{format}','json').sub('{' + 'id' + '}', escapeString(id))
+        
+
+        # 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 })
+        if response
+          Attune::Model::Blacklist.new(JSON.parse(response.body))
+        else
+          mockProc = MOCKS['Entities.blacklist_get']
+          if mockProc
+            mockResponse = mockProc.call(id)
+            Attune::Model::Blacklist.new(mockResponse)
           else
             nil
           end

data/lib/attune/models/blacklist.rb

@@ -3,40 +3,44 @@ module Attune
     # 
     #
     # @attr [String] id 
-    # @attr [Boolean] disabled 
-    # @attr [String] consumer 
     # @attr [String] entity_type 
-    # @attr [String] start_date 
+    # @attr [String] consumer 
     # @attr [String] end_date 
+    # @attr [Boolean] disabled 
     # @attr [String] created_at 
-    # @attr [Array<String>] ids 
+    # @attr [String] start_date 
     # @attr [Array<String>] scope 
+    # @attr [Array<String>] ids 
+    # @attr [Boolean] active 
     class Blacklist
       attr_accessor :id
       
 
-      attr_accessor :disabled
+      attr_accessor :entity_type
       
 
       attr_accessor :consumer
       
 
-      attr_accessor :entity_type
+      attr_accessor :end_date
       
 
-      attr_accessor :start_date
+      attr_accessor :disabled
       
 
-      attr_accessor :end_date
+      attr_accessor :created_at
       
 
-      attr_accessor :created_at
+      attr_accessor :start_date
+      
+
+      attr_accessor :scope
       
 
       attr_accessor :ids
       
 
-      attr_accessor :scope
+      attr_accessor :active
       
 
       def initialize(attributes = {})
@@ -44,27 +48,29 @@ module Attune
         # Workaround since JSON.parse has accessors as strings rather than symbols
         @id = attributes["id"] || attributes[:"id"]
         # Workaround since JSON.parse has accessors as strings rather than symbols
-        @disabled = attributes["disabled"] || attributes[:"disabled"]
-        # Workaround since JSON.parse has accessors as strings rather than symbols
-        @consumer = attributes["consumer"] || attributes[:"consumer"]
-        # Workaround since JSON.parse has accessors as strings rather than symbols
         @entity_type = attributes["entityType"] || attributes[:"entity_type"]
         # Workaround since JSON.parse has accessors as strings rather than symbols
-        @start_date = attributes["startDate"] || attributes[:"start_date"]
+        @consumer = attributes["consumer"] || attributes[:"consumer"]
         # Workaround since JSON.parse has accessors as strings rather than symbols
         @end_date = attributes["endDate"] || attributes[:"end_date"]
         # Workaround since JSON.parse has accessors as strings rather than symbols
+        @disabled = attributes["disabled"] || attributes[:"disabled"]
+        # Workaround since JSON.parse has accessors as strings rather than symbols
         @created_at = attributes["createdAt"] || attributes[:"created_at"]
-        value = attributes["ids"] || attributes[:"ids"]
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @start_date = attributes["startDate"] || attributes[:"start_date"]
+        value = attributes["scope"] || attributes[:"scope"]
         if value.is_a?(Array)
-          @ids = value
+          @scope = value
 
         end
-        value = attributes["scope"] || attributes[:"scope"]
+        value = attributes["ids"] || attributes[:"ids"]
         if value.is_a?(Array)
-          @scope = value
+          @ids = value
 
         end
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @active = attributes["active"] || attributes[:"active"]
         
 
       end
@@ -84,14 +90,15 @@ module Attune
       # :internal => :external
       ATTRIBUTE_MAP = {
           :id => :id,
-          :disabled => :disabled,
-          :consumer => :consumer,
           :entity_type => :entityType,
-          :start_date => :startDate,
+          :consumer => :consumer,
           :end_date => :endDate,
+          :disabled => :disabled,
           :created_at => :createdAt,
+          :start_date => :startDate,
+          :scope => :scope,
           :ids => :ids,
-          :scope => :scope
+          :active => :active
 
         }
     end

data/lib/attune/models/blacklist_delete_response.rb

@@ -0,0 +1,38 @@
+module Attune
+  module Model
+    # 
+    #
+    # @attr [String] result 
+    class BlacklistDeleteResponse
+      attr_accessor :result
+      
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @result = attributes["result"] || attributes[:"result"]
+        
+
+      end
+
+      def to_body
+        Hash[ATTRIBUTE_MAP.map do |internal, external|
+          next unless value = send(internal)
+          [external, value]
+        end.compact]
+      end
+
+      def to_json(options = {})
+        to_body.to_json
+      end
+
+      private
+      # :internal => :external
+      ATTRIBUTE_MAP = {
+          :result => :result
+
+        }
+    end
+  end
+end
+

data/lib/attune/models/blacklist_params.rb

@@ -2,14 +2,14 @@ module Attune
   module Model
     # 
     #
-    # @attr [Array<String>] scope 
+    # @attr [Boolean] disabled 
     # @attr [String] entity_type 
     # @attr [Array<String>] ids 
-    # @attr [Boolean] disabled 
+    # @attr [Array<Attune::Model::ScopeEntry>] scope 
     # @attr [String] active_from 
     # @attr [String] active_to 
     class BlacklistParams
-      attr_accessor :scope
+      attr_accessor :disabled
       
 
       attr_accessor :entity_type
@@ -18,7 +18,7 @@ module Attune
       attr_accessor :ids
       
 
-      attr_accessor :disabled
+      attr_accessor :scope
       
 
       attr_accessor :active_from
@@ -29,11 +29,8 @@ module Attune
 
       def initialize(attributes = {})
         return if attributes.empty?
-        value = attributes["scope"] || attributes[:"scope"]
-        if value.is_a?(Array)
-          @scope = value
-
-        end
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @disabled = attributes["disabled"] || attributes[:"disabled"]
         # Workaround since JSON.parse has accessors as strings rather than symbols
         @entity_type = attributes["entityType"] || attributes[:"entity_type"]
         value = attributes["ids"] || attributes[:"ids"]
@@ -41,8 +38,11 @@ module Attune
           @ids = value
 
         end
-        # Workaround since JSON.parse has accessors as strings rather than symbols
-        @disabled = attributes["disabled"] || attributes[:"disabled"]
+        value = attributes["scope"] || attributes[:"scope"]
+        if value.is_a?(Array)
+          @scope = value.map{ |v| ScopeEntry.new(v) }
+
+        end
         # Workaround since JSON.parse has accessors as strings rather than symbols
         @active_from = attributes["activeFrom"] || attributes[:"active_from"]
         # Workaround since JSON.parse has accessors as strings rather than symbols
@@ -65,10 +65,10 @@ module Attune
       private
       # :internal => :external
       ATTRIBUTE_MAP = {
-          :scope => :scope,
+          :disabled => :disabled,
           :entity_type => :entityType,
           :ids => :ids,
-          :disabled => :disabled,
+          :scope => :scope,
           :active_from => :activeFrom,
           :active_to => :activeTo
 

data/lib/attune/models/blacklist_update_response.rb

@@ -0,0 +1,38 @@
+module Attune
+  module Model
+    # 
+    #
+    # @attr [String] result 
+    class BlacklistUpdateResponse
+      attr_accessor :result
+      
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @result = attributes["result"] || attributes[:"result"]
+        
+
+      end
+
+      def to_body
+        Hash[ATTRIBUTE_MAP.map do |internal, external|
+          next unless value = send(internal)
+          [external, value]
+        end.compact]
+      end
+
+      def to_json(options = {})
+        to_body.to_json
+      end
+
+      private
+      # :internal => :external
+      ATTRIBUTE_MAP = {
+          :result => :result
+
+        }
+    end
+  end
+end
+

data/lib/attune/models/ranked_entities.rb

@@ -3,29 +3,29 @@ module Attune
     # List of ids in ranked order. If an error occurs, returns message and status code.
     #
     # @attr [String] message Error message if ranking failed
-    # @attr [Array<String>] ranking List of ids in ranked order
     # @attr [Integer] status HTTP status code if ranking failed
+    # @attr [Array<String>] ranking List of ids in ranked order
     class RankedEntities
       attr_accessor :message
       
 
-      attr_accessor :ranking
+      attr_accessor :status
       
 
-      attr_accessor :status
+      attr_accessor :ranking
       
 
       def initialize(attributes = {})
         return if attributes.empty?
         # Workaround since JSON.parse has accessors as strings rather than symbols
         @message = attributes["message"] || attributes[:"message"]
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @status = attributes["status"] || attributes[:"status"]
         value = attributes["ranking"] || attributes[:"ranking"]
         if value.is_a?(Array)
           @ranking = value
 
         end
-        # Workaround since JSON.parse has accessors as strings rather than symbols
-        @status = attributes["status"] || attributes[:"status"]
         
 
       end
@@ -45,8 +45,8 @@ module Attune
       # :internal => :external
       ATTRIBUTE_MAP = {
           :message => :message,
-          :ranking => :ranking,
-          :status => :status
+          :status => :status,
+          :ranking => :ranking
 
         }
     end

data/lib/attune/models/ranking_params.rb

@@ -2,25 +2,25 @@ module Attune
   module Model
     # Inputs for ranking a set of ids for a particular user.
     #
-    # @attr [Array<Attune::Model::ScopeEntry>] scope 
     # @attr [String] view 
-    # @attr [String] ip 
     # @attr [String] user_agent 
+    # @attr [String] ip 
+    # @attr [String] customer 
     # @attr [String] entity_type 
     # @attr [Array<String>] ids 
-    # @attr [String] customer 
+    # @attr [Array<Attune::Model::ScopeEntry>] scope 
     # @attr [String] anonymous 
     class RankingParams
-      attr_accessor :scope
+      attr_accessor :view
       
 
-      attr_accessor :view
+      attr_accessor :user_agent
       
 
       attr_accessor :ip
       
 
-      attr_accessor :user_agent
+      attr_accessor :customer
       
 
       attr_accessor :entity_type
@@ -29,7 +29,7 @@ module Attune
       attr_accessor :ids
       
 
-      attr_accessor :customer
+      attr_accessor :scope
       
 
       attr_accessor :anonymous
@@ -37,17 +37,14 @@ module Attune
 
       def initialize(attributes = {})
         return if attributes.empty?
-        value = attributes["scope"] || attributes[:"scope"]
-        if value.is_a?(Array)
-          @scope = value.map{ |v| ScopeEntry.new(v) }
-
-        end
         # Workaround since JSON.parse has accessors as strings rather than symbols
         @view = attributes["view"] || attributes[:"view"]
         # Workaround since JSON.parse has accessors as strings rather than symbols
+        @user_agent = attributes["userAgent"] || attributes[:"user_agent"]
+        # Workaround since JSON.parse has accessors as strings rather than symbols
         @ip = attributes["ip"] || attributes[:"ip"]
         # Workaround since JSON.parse has accessors as strings rather than symbols
-        @user_agent = attributes["userAgent"] || attributes[:"user_agent"]
+        @customer = attributes["customer"] || attributes[:"customer"]
         # Workaround since JSON.parse has accessors as strings rather than symbols
         @entity_type = attributes["entityType"] || attributes[:"entity_type"]
         value = attributes["ids"] || attributes[:"ids"]
@@ -55,8 +52,11 @@ module Attune
           @ids = value
 
         end
-        # Workaround since JSON.parse has accessors as strings rather than symbols
-        @customer = attributes["customer"] || attributes[:"customer"]
+        value = attributes["scope"] || attributes[:"scope"]
+        if value.is_a?(Array)
+          @scope = value.map{ |v| ScopeEntry.new(v) }
+
+        end
         # Workaround since JSON.parse has accessors as strings rather than symbols
         @anonymous = attributes["anonymous"] || attributes[:"anonymous"]
         
@@ -77,13 +77,13 @@ module Attune
       private
       # :internal => :external
       ATTRIBUTE_MAP = {
-          :scope => :scope,
           :view => :view,
-          :ip => :ip,
           :user_agent => :userAgent,
+          :ip => :ip,
+          :customer => :customer,
           :entity_type => :entityType,
           :ids => :ids,
-          :customer => :customer,
+          :scope => :scope,
           :anonymous => :anonymous
 
         }

data/lib/attune/version.rb

@@ -1,4 +1,4 @@
 module Attune
-  VERSION = "1.0.9"
+  VERSION = "1.0.10"
 end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: attune
 version: !ruby/object:Gem::Version
-  version: 1.0.9
+  version: 1.0.10
 platform: ruby
 authors:
 - John Hawthorn
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-22 00:00:00.000000000 Z
+date: 2014-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -154,9 +154,11 @@ files:
 - lib/attune/models/batch_ranking_request.rb
 - lib/attune/models/batch_ranking_result.rb
 - lib/attune/models/blacklist.rb
+- lib/attune/models/blacklist_delete_response.rb
 - lib/attune/models/blacklist_get_response.rb
 - lib/attune/models/blacklist_params.rb
 - lib/attune/models/blacklist_save_response.rb
+- lib/attune/models/blacklist_update_response.rb
 - lib/attune/models/customer.rb
 - lib/attune/models/ranked_entities.rb
 - lib/attune/models/ranking_params.rb
@@ -201,3 +203,4 @@ test_files:
 - spec/attune_spec.rb
 - spec/remote_spec.rb
 - spec/spec_helper.rb
+has_rdoc: