attune 1.0.3 → 1.0.5

data/lib/attune/configurable.rb

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

data/lib/attune/default.rb

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

data/lib/attune/json_logger.rb

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

data/lib/attune/models/anonymousresult.rb

@@ -0,0 +1,41 @@
+module Attune
+  module Model
+    # 
+    class AnonymousResult
+      attr_accessor :id
+      
+
+      # :internal => :external
+      def self.attribute_map
+        {
+          :id => :id
+
+        }
+      end
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        # Morph attribute keys into undescored rubyish style
+        if self.class.attribute_map[:"id"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @id = attributes["id"] || attributes[:"id"]
+        end
+        
+
+      end
+
+      def to_body
+        body = {}
+        self.class.attribute_map.each_pair do |key, value|
+          body[value] = self.send(key) unless self.send(key).nil?
+        end
+        body
+      end
+
+      def to_json(options = {})
+        to_body.to_json
+      end
+    end
+  end
+end
+

data/lib/attune/models/batchrankingrequest.rb

@@ -0,0 +1,44 @@
+module Attune
+  module Model
+    # 
+    class BatchRankingRequest
+      attr_accessor :requests
+      
+
+      # :internal => :external
+      def self.attribute_map
+        {
+          :requests => :requests
+
+        }
+      end
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        # Morph attribute keys into undescored rubyish style
+        if self.class.attribute_map[:"requests"]
+          value = attributes["requests"] || attributes[:"requests"]
+            if value.is_a?(Array)
+              @requests = value.map{ |v| RankingParams.new(v) }
+
+            end
+          end
+        
+
+      end
+
+      def to_body
+        body = {}
+        self.class.attribute_map.each_pair do |key, value|
+          body[value] = self.send(key) unless self.send(key).nil?
+        end
+        body
+      end
+
+      def to_json(options = {})
+        to_body.to_json
+      end
+    end
+  end
+end
+

data/lib/attune/models/batchrankingresult.rb

@@ -0,0 +1,44 @@
+module Attune
+  module Model
+    # 
+    class BatchRankingResult
+      attr_accessor :results
+      
+
+      # :internal => :external
+      def self.attribute_map
+        {
+          :results => :results
+
+        }
+      end
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        # Morph attribute keys into undescored rubyish style
+        if self.class.attribute_map[:"results"]
+          value = attributes["results"] || attributes[:"results"]
+            if value.is_a?(Array)
+              @results = value.map{ |v| RankedEntities.new(v) }
+
+            end
+          end
+        
+
+      end
+
+      def to_body
+        body = {}
+        self.class.attribute_map.each_pair do |key, value|
+          body[value] = self.send(key) unless self.send(key).nil?
+        end
+        body
+      end
+
+      def to_json(options = {})
+        to_body.to_json
+      end
+    end
+  end
+end
+

data/lib/attune/models/blacklist.rb

@@ -0,0 +1,111 @@
+module Attune
+  module Model
+    # 
+    class Blacklist
+      attr_accessor :id
+      
+
+      attr_accessor :ids
+      
+
+      attr_accessor :entity_type
+      
+
+      attr_accessor :consumer
+      
+
+      attr_accessor :created_at
+      
+
+      attr_accessor :end_date
+      
+
+      attr_accessor :start_date
+      
+
+      attr_accessor :disabled
+      
+
+      attr_accessor :scope
+      
+
+      # :internal => :external
+      def self.attribute_map
+        {
+          :id => :id,
+          :ids => :ids,
+          :entity_type => :entityType,
+          :consumer => :consumer,
+          :created_at => :createdAt,
+          :end_date => :endDate,
+          :start_date => :startDate,
+          :disabled => :disabled,
+          :scope => :scope
+
+        }
+      end
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        # Morph attribute keys into undescored rubyish style
+        if self.class.attribute_map[:"id"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @id = attributes["id"] || attributes[:"id"]
+        end
+        if self.class.attribute_map[:"ids"]
+          value = attributes["ids"] || attributes[:"ids"]
+            if value.is_a?(Array)
+              @ids = value
+
+            end
+          end
+        if self.class.attribute_map[:"entity_type"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @entity_type = attributes["entityType"] || attributes[:"entity_type"]
+        end
+        if self.class.attribute_map[:"consumer"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @consumer = attributes["consumer"] || attributes[:"consumer"]
+        end
+        if self.class.attribute_map[:"created_at"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @created_at = attributes["createdAt"] || attributes[:"created_at"]
+        end
+        if self.class.attribute_map[:"end_date"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @end_date = attributes["endDate"] || attributes[:"end_date"]
+        end
+        if self.class.attribute_map[:"start_date"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @start_date = attributes["startDate"] || attributes[:"start_date"]
+        end
+        if self.class.attribute_map[:"disabled"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @disabled = attributes["disabled"] || attributes[:"disabled"]
+        end
+        if self.class.attribute_map[:"scope"]
+          value = attributes["scope"] || attributes[:"scope"]
+            if value.is_a?(Array)
+              @scope = value
+
+            end
+          end
+        
+
+      end
+
+      def to_body
+        body = {}
+        self.class.attribute_map.each_pair do |key, value|
+          body[value] = self.send(key) unless self.send(key).nil?
+        end
+        body
+      end
+
+      def to_json(options = {})
+        to_body.to_json
+      end
+    end
+  end
+end
+

data/lib/attune/models/blacklistgetresponse.rb

@@ -0,0 +1,44 @@
+module Attune
+  module Model
+    # 
+    class BlacklistGetResponse
+      attr_accessor :blacklists
+      
+
+      # :internal => :external
+      def self.attribute_map
+        {
+          :blacklists => :blacklists
+
+        }
+      end
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        # Morph attribute keys into undescored rubyish style
+        if self.class.attribute_map[:"blacklists"]
+          value = attributes["blacklists"] || attributes[:"blacklists"]
+            if value.is_a?(Array)
+              @blacklists = value.map{ |v| Blacklist.new(v) }
+
+            end
+          end
+        
+
+      end
+
+      def to_body
+        body = {}
+        self.class.attribute_map.each_pair do |key, value|
+          body[value] = self.send(key) unless self.send(key).nil?
+        end
+        body
+      end
+
+      def to_json(options = {})
+        to_body.to_json
+      end
+    end
+  end
+end
+

data/lib/attune/models/blacklistparams.rb

@@ -0,0 +1,87 @@
+module Attune
+  module Model
+    # 
+    class BlacklistParams
+      attr_accessor :entity_type
+      
+
+      attr_accessor :disabled
+      
+
+      attr_accessor :ids
+      
+
+      attr_accessor :scope
+      
+
+      attr_accessor :active_from
+      
+
+      attr_accessor :active_to
+      
+
+      # :internal => :external
+      def self.attribute_map
+        {
+          :entity_type => :entityType,
+          :disabled => :disabled,
+          :ids => :ids,
+          :scope => :scope,
+          :active_from => :activeFrom,
+          :active_to => :activeTo
+
+        }
+      end
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        # Morph attribute keys into undescored rubyish style
+        if self.class.attribute_map[:"entity_type"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @entity_type = attributes["entityType"] || attributes[:"entity_type"]
+        end
+        if self.class.attribute_map[:"disabled"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @disabled = attributes["disabled"] || attributes[:"disabled"]
+        end
+        if self.class.attribute_map[:"ids"]
+          value = attributes["ids"] || attributes[:"ids"]
+            if value.is_a?(Array)
+              @ids = value
+
+            end
+          end
+        if self.class.attribute_map[:"scope"]
+          value = attributes["scope"] || attributes[:"scope"]
+            if value.is_a?(Array)
+              @scope = value
+
+            end
+          end
+        if self.class.attribute_map[:"active_from"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @active_from = attributes["activeFrom"] || attributes[:"active_from"]
+        end
+        if self.class.attribute_map[:"active_to"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @active_to = attributes["activeTo"] || attributes[:"active_to"]
+        end
+        
+
+      end
+
+      def to_body
+        body = {}
+        self.class.attribute_map.each_pair do |key, value|
+          body[value] = self.send(key) unless self.send(key).nil?
+        end
+        body
+      end
+
+      def to_json(options = {})
+        to_body.to_json
+      end
+    end
+  end
+end
+

data/lib/attune/models/blacklistsaveresponse.rb

@@ -0,0 +1,41 @@
+module Attune
+  module Model
+    # 
+    class BlacklistSaveResponse
+      attr_accessor :result
+      
+
+      # :internal => :external
+      def self.attribute_map
+        {
+          :result => :result
+
+        }
+      end
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        # Morph attribute keys into undescored rubyish style
+        if self.class.attribute_map[:"result"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @result = attributes["result"] || attributes[:"result"]
+        end
+        
+
+      end
+
+      def to_body
+        body = {}
+        self.class.attribute_map.each_pair do |key, value|
+          body[value] = self.send(key) unless self.send(key).nil?
+        end
+        body
+      end
+
+      def to_json(options = {})
+        to_body.to_json
+      end
+    end
+  end
+end
+

data/lib/attune/models/customer.rb

@@ -0,0 +1,41 @@
+module Attune
+  module Model
+    # customer associated with an anonymous user
+    class Customer
+      attr_accessor :customer
+      
+
+      # :internal => :external
+      def self.attribute_map
+        {
+          :customer => :customer
+
+        }
+      end
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        # Morph attribute keys into undescored rubyish style
+        if self.class.attribute_map[:"customer"]
+          # Workaround since JSON.parse has accessors as strings rather than symbols
+            @customer = attributes["customer"] || attributes[:"customer"]
+        end
+        
+
+      end
+
+      def to_body
+        body = {}
+        self.class.attribute_map.each_pair do |key, value|
+          body[value] = self.send(key) unless self.send(key).nil?
+        end
+        body
+      end
+
+      def to_json(options = {})
+        to_body.to_json
+      end
+    end
+  end
+end
+