attune 1.0.5 → 1.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: eb1defe49351ac0ececcbee2e6234ecd06dd923e
-  data.tar.gz: f5d0b12d7b5f6514847b2de1bcd07977b1b6acfb
+  metadata.gz: f989d86ece4bbcff8762dbfc11c3879e7b057913
+  data.tar.gz: ef029ed4b38d4d0ed4a8dc072646bcf37e474a1e
 SHA512:
-  metadata.gz: 0251f285edcf9c2e759928f87ac2407e2e6cd274ee71bceda05b959a87a64eb26a7eadce39744fc5fc8c0c60d654d2b4cae3a1d222d8bffcc7e514cde8afb79c
-  data.tar.gz: 07d2c0d9cae0cecf2158438e9597832c0fcad15f9e1f455cefde22bde4f2dbf81aa73d14d4f32c4f40cce1ab119f5897a8d9950e7f0c17126f7ee218f1492e36
+  metadata.gz: 6f00289644fedfcb042e5cc19a2001d60707f22c2ea0548e4a38a00133ca0f756a865b2b1105c18078618398bbca32ca48f374d1a83a34c391d9f829e41e5672
+  data.tar.gz: fbda6bd0e3aa269e23bdbcda5419f6c9292f96d418da688bec8155d8e0d9013f0586097443402bbb37896b9dfb294ea65d65eefcb3ac81f93aae2e9f1adfdaae

data/README.md

@@ -31,7 +31,7 @@ Visitors to the application should be tagged with an anonymous user id
 ``` ruby
 class ApplicationController
   before_filter do
-    session[:attune_id] ||= attune_client.create_anonymous(user_agent: request.env["HTTP_USER_AGENT"])
+    session[:attune_id] ||= attune_client.anonymous.create.id
   end
 
   private
@@ -49,7 +49,8 @@ class SessionsController
 
   def create
     # ...
-    attune_client.bind(session[:attune_id], current_user.id)
+    attune_customer = Attune::Model::Customer.new(customer: current_user.id)
+    attune_client.anonymous.update(session[:attune_id], attune_customer)
   end
 end
 ```
@@ -64,14 +65,15 @@ class ProductsController
 
   private
   def sorted products
-    ranking = attune_client.get_rankings(
-      id: session[:attune_id],
-      view: request.fullpath,
-      collection: 'products',
-      entities: products.map(&:id)
-    )
+    ranking_params = Attune::Model::RankingParams.new
+    ranking_params.anonymous = session[:attune_id]
+    ranking_params.view = request.fullpath
+    ranking_params.entity_type = 'products'
+    ranking_params.user_agent = request.env["HTTP_USER_AGENT"]
+    ranking_params.ids = products.map(&:id)
+    ranking = attune_client.entities.get_rankings(ranking_params)
     products.sort_by do |product|
-      ranking[:entities].index(product.id.to_s)
+      ranking.ranking.index(product.id.to_s)
     end
   end
 end

data/lib/attune.rb

@@ -4,19 +4,20 @@ require "attune/version"
 require "attune/configurable"
 require "attune/default"
 require "attune/client"
+require "attune/mocks"
 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/blacklist_get_response"
+require "attune/models/anonymous_result"
+require "attune/models/blacklist_params"
+require "attune/models/ranked_entities"
+require "attune/models/ranking_params"
 require "attune/models/customer"
 require "attune/models/blacklist"
-require "attune/models/batchrankingrequest"
-require "attune/models/scopeentry"
-require "attune/models/blacklistsaveresponse"
-require "attune/models/batchrankingresult"
+require "attune/models/batch_ranking_request"
+require "attune/models/scope_entry"
+require "attune/models/blacklist_save_response"
+require "attune/models/batch_ranking_result"
 
 module Attune
   def self.client

data/lib/attune/api/anonymous.rb

@@ -10,14 +10,10 @@ module Attune
         @client = client
       end
 
-      def escapeString(string)
-        URI.encode(string.to_s)
-      end
-
-      # Creates an anonymous visitor.
+      # Create anonymous visitor
       #
       # @return [Attune::Model::AnonymousResult]
-      # @raise [ArgumentError] if user_agent is not provided
+      # @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 create ()
@@ -38,26 +34,35 @@ module Attune
         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))
+        if response
+          Attune::Model::AnonymousResult.new(JSON.parse(response.body))
+        else
+          mockProc = MOCKS['Anonymous.create']
+          if mockProc
+            mockResponse = mockProc.call()
+            Attune::Model::AnonymousResult.new(mockResponse)
+          else
+            nil
+          end
+        end
+        
       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 [Customer] body
-      # @raise [ArgumentError] if user_agent is not provided
+      # @param [String] anonymous
+      # @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 "anonymous is required" if anonymous.nil?
-        raise "body is required" if body.nil?
+        raise ArgumentError, "anonymous is required" if anonymous.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))
@@ -70,45 +75,38 @@ 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
       
-      # get
+      # Binds one actor to another, allowing activities of those actors to be shared between the two.
       #
-      # @param [string] anonymous
-      # @return [Attune::Model::Customer]
-      # @raise [ArgumentError] if user_agent is not provided
+      # @param [String] anonymous
+      # @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 "anonymous is required" if anonymous.nil?
+        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))
@@ -121,11 +119,35 @@ module Attune
 
         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))
+        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
       
+      private
+      def escapeString(string)
+        URI.encode(string.to_s)
       end
+    end
   end
 end
 

data/lib/attune/api/entities.rb

@@ -10,14 +10,10 @@ module Attune
         @client = client
       end
 
-      def escapeString(string)
-        URI.encode(string.to_s)
-      end
-
-      # blacklistGet
+      # List all blacklist entries for your account.
       #
       # @return [Attune::Model::BlacklistGetResponse]
-      # @raise [ArgumentError] if user_agent is not provided
+      # @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 ()
@@ -38,14 +34,25 @@ module Attune
         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))
+        if response
+          Attune::Model::BlacklistGetResponse.new(JSON.parse(response.body))
+        else
+          mockProc = MOCKS['Entities.blacklist_get']
+          if mockProc
+            mockResponse = mockProc.call()
+            Attune::Model::BlacklistGetResponse.new(mockResponse)
+          else
+            nil
+          end
+        end
+        
       end
       
-      # blacklistSave
+      # Save a new blacklist entry.
       #
-      # @param [BlacklistParams] body
+      # @param [Attune::Model::BlacklistParams] body
       # @return [Attune::Model::BlacklistSaveResponse]
-      # @raise [ArgumentError] if user_agent is not provided
+      # @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)
@@ -79,28 +86,39 @@ module Attune
 
           else
             if body.respond_to?("to_body".to_sym)
-    	        post_body = body.to_body
-    	      else
-    	        post_body = body
-    	      end
+              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))
+        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
       
-      # getRankings
+      # Returns a ranking of the specified entities for the current user.
       #
-      # @param [RankingParams] body
+      # @param [Attune::Model::RankingParams] body
       # @return [Attune::Model::RankedEntities]
-      # @raise [ArgumentError] if user_agent is not provided
+      # @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_rankings (body)
         query_param_keys = []
 
         # verify existence of params
-        raise "body is required" if body.nil?
+        raise ArgumentError, "body is required" if body.nil?
         # set default values and merge with input
         options = {
         :body => body}
@@ -129,28 +147,39 @@ module Attune
 
           else
             if body.respond_to?("to_body".to_sym)
-    	        post_body = body.to_body
-    	      else
-    	        post_body = body
-    	      end
+              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))
+        if response
+          Attune::Model::RankedEntities.new(JSON.parse(response.body))
+        else
+          mockProc = MOCKS['Entities.get_rankings']
+          if mockProc
+            mockResponse = mockProc.call(body)
+            Attune::Model::RankedEntities.new(mockResponse)
+          else
+            nil
+          end
+        end
+        
       end
       
-      # batchGetRankings
+      # Returns multiple rankings of the specified entities for the current user.
       #
-      # @param [BatchRankingRequest] body
+      # @param [Attune::Model::BatchRankingRequest] body
       # @return [Attune::Model::BatchRankingResult]
-      # @raise [ArgumentError] if user_agent is not provided
+      # @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 batch_get_rankings (body)
         query_param_keys = []
 
         # verify existence of params
-        raise "body is required" if body.nil?
+        raise ArgumentError, "body is required" if body.nil?
         # set default values and merge with input
         options = {
         :body => body}
@@ -179,17 +208,32 @@ module Attune
 
           else
             if body.respond_to?("to_body".to_sym)
-    	        post_body = body.to_body
-    	      else
-    	        post_body = body
-    	      end
+              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))
+        if response
+          Attune::Model::BatchRankingResult.new(JSON.parse(response.body))
+        else
+          mockProc = MOCKS['Entities.batch_get_rankings']
+          if mockProc
+            mockResponse = mockProc.call(body)
+            Attune::Model::BatchRankingResult.new(mockResponse)
+          else
+            nil
+          end
+        end
+        
       end
       
+      private
+      def escapeString(string)
+        URI.encode(string.to_s)
       end
+    end
   end
 end
 

data/lib/attune/client.rb

@@ -67,8 +67,6 @@ module Attune
 
     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'

data/lib/attune/default.rb

@@ -8,7 +8,7 @@ module Attune
   module Default
     extend Configurable
 
-    ENDPOINT = "http://localhost/".freeze
+    ENDPOINT = "https://api.attune-staging.co".freeze
 
     # user our version of NetHttpPersistent adapter
     Faraday::Adapter.register_middleware(attune_http_persistent: NetHttpPersistent)