attune 1.0.5 → 1.0.6

data/lib/attune/mocks.rb

@@ -0,0 +1,11 @@
+module Attune
+  MOCKS = {
+    'Anonymous.create' => Proc.new{ {:id => SecureRandom.uuid } },
+    'Entities.get_rankings' => Proc.new{ |body| { :ranking => body.ids.map(&:to_s) } },
+    'Entities.batch_get_rankings' => Proc.new{ |body|
+        { :results =>  body.requests.map {
+            |params| { :ranking => params.ids.map(&:to_s) }
+        } }
+    }
+  }
+end

data/lib/attune/models/anonymous_result.rb

@@ -0,0 +1,38 @@
+module Attune
+  module Model
+    # Result of creating an anonymous user.
+    #
+    # @attr [String] id
+    class AnonymousResult
+      attr_accessor :id
+      
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @id = attributes["id"] || attributes[:"id"]
+        
+
+      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 = {
+          :id => :id
+
+        }
+    end
+  end
+end
+

data/lib/attune/models/batch_ranking_request.rb

@@ -0,0 +1,41 @@
+module Attune
+  module Model
+    # Wrapper for requesting multiple rankings in a single call.
+    #
+    # @attr [Array<Attune::Model::RankingParams>] requests
+    class BatchRankingRequest
+      attr_accessor :requests
+      
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        value = attributes["requests"] || attributes[:"requests"]
+        if value.is_a?(Array)
+          @requests = value.map{ |v| RankingParams.new(v) }
+
+        end
+        
+
+      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 = {
+          :requests => :requests
+
+        }
+    end
+  end
+end
+

data/lib/attune/models/batch_ranking_result.rb

@@ -0,0 +1,41 @@
+module Attune
+  module Model
+    # Wrapper of multiple ranking results.
+    #
+    # @attr [Array<Attune::Model::RankedEntities>] results
+    class BatchRankingResult
+      attr_accessor :results
+      
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        value = attributes["results"] || attributes[:"results"]
+        if value.is_a?(Array)
+          @results = value.map{ |v| RankedEntities.new(v) }
+
+        end
+        
+
+      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 = {
+          :results => :results
+
+        }
+    end
+  end
+end
+

data/lib/attune/models/blacklist.rb

@@ -1,6 +1,16 @@
 module Attune
   module Model
     # 
+    #
+    # @attr [String] id
+    # @attr [Array<String>] ids
+    # @attr [Boolean] disabled
+    # @attr [Array<String>] scope
+    # @attr [String] consumer
+    # @attr [String] entity_type
+    # @attr [String] start_date
+    # @attr [String] end_date
+    # @attr [String] created_at
     class Blacklist
       attr_accessor :id
       
@@ -8,103 +18,82 @@ module Attune
       attr_accessor :ids
       
 
-      attr_accessor :entity_type
+      attr_accessor :disabled
       
 
-      attr_accessor :consumer
+      attr_accessor :scope
       
 
-      attr_accessor :created_at
+      attr_accessor :consumer
       
 
-      attr_accessor :end_date
+      attr_accessor :entity_type
       
 
       attr_accessor :start_date
       
 
-      attr_accessor :disabled
+      attr_accessor :end_date
       
 
-      attr_accessor :scope
+      attr_accessor :created_at
       
 
-      # :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"]
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @id = attributes["id"] || attributes[:"id"]
+        value = attributes["ids"] || attributes[:"ids"]
+        if value.is_a?(Array)
+          @ids = value
+
         end
-        if self.class.attribute_map[:"scope"]
-          value = attributes["scope"] || attributes[:"scope"]
-            if value.is_a?(Array)
-              @scope = value
+        # 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
 
-            end
-          end
+        end
+        # 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"]
+        # 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
+        @created_at = attributes["createdAt"] || attributes[:"created_at"]
         
 
       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
+        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 = {
+          :id => :id,
+          :ids => :ids,
+          :disabled => :disabled,
+          :scope => :scope,
+          :consumer => :consumer,
+          :entity_type => :entityType,
+          :start_date => :startDate,
+          :end_date => :endDate,
+          :created_at => :createdAt
+
+        }
     end
   end
 end

data/lib/attune/models/blacklist_get_response.rb

@@ -0,0 +1,41 @@
+module Attune
+  module Model
+    # 
+    #
+    # @attr [Array<Attune::Model::Blacklist>] blacklists
+    class BlacklistGetResponse
+      attr_accessor :blacklists
+      
+
+      def initialize(attributes = {})
+        return if attributes.empty?
+        value = attributes["blacklists"] || attributes[:"blacklists"]
+        if value.is_a?(Array)
+          @blacklists = value.map{ |v| Blacklist.new(v) }
+
+        end
+        
+
+      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 = {
+          :blacklists => :blacklists
+
+        }
+    end
+  end
+end
+

data/lib/attune/models/blacklist_params.rb

@@ -0,0 +1,79 @@
+module Attune
+  module Model
+    # 
+    #
+    # @attr [Array<String>] scope
+    # @attr [String] active_from
+    # @attr [String] active_to
+    # @attr [String] entity_type
+    # @attr [Array<String>] ids
+    # @attr [Boolean] disabled
+    class BlacklistParams
+      attr_accessor :scope
+      
+
+      attr_accessor :active_from
+      
+
+      attr_accessor :active_to
+      
+
+      attr_accessor :entity_type
+      
+
+      attr_accessor :ids
+      
+
+      attr_accessor :disabled
+      
+
+      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
+        @active_from = attributes["activeFrom"] || attributes[:"active_from"]
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @active_to = attributes["activeTo"] || attributes[:"active_to"]
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @entity_type = attributes["entityType"] || attributes[:"entity_type"]
+        value = attributes["ids"] || attributes[:"ids"]
+        if value.is_a?(Array)
+          @ids = value
+
+        end
+        # Workaround since JSON.parse has accessors as strings rather than symbols
+        @disabled = attributes["disabled"] || attributes[:"disabled"]
+        
+
+      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 = {
+          :scope => :scope,
+          :active_from => :activeFrom,
+          :active_to => :activeTo,
+          :entity_type => :entityType,
+          :ids => :ids,
+          :disabled => :disabled
+
+        }
+    end
+  end
+end
+

data/lib/attune/models/blacklist_save_response.rb

@@ -0,0 +1,38 @@
+module Attune
+  module Model
+    # 
+    #
+    # @attr [String] result
+    class BlacklistSaveResponse
+      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
+