attune 1.0.5 → 1.0.6

data/lib/attune/models/batchrankingrequest.rb

@@ -1,44 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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/blacklistgetresponse.rb

@@ -1,44 +0,0 @@
-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

@@ -1,87 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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/rankedentities.rb

@@ -1,60 +0,0 @@
-module Attune
-  module Model
-    # 
-    class RankedEntities
-      attr_accessor :message
-      
-
-      attr_accessor :status
-      
-
-      attr_accessor :ranking
-      
-
-      # :internal => :external
-      def self.attribute_map
-        {
-          :message => :message,
-          :status => :status,
-          :ranking => :ranking
-
-        }
-      end
-
-      def initialize(attributes = {})
-        return if attributes.empty?
-        # Morph attribute keys into undescored rubyish style
-        if self.class.attribute_map[:"message"]
-          # Workaround since JSON.parse has accessors as strings rather than symbols
-            @message = attributes["message"] || attributes[:"message"]
-        end
-        if self.class.attribute_map[:"status"]
-          # Workaround since JSON.parse has accessors as strings rather than symbols
-            @status = attributes["status"] || attributes[:"status"]
-        end
-        if self.class.attribute_map[:"ranking"]
-          value = attributes["ranking"] || attributes[:"ranking"]
-            if value.is_a?(Array)
-              @ranking = 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/rankingparams.rb

@@ -1,103 +0,0 @@
-module Attune
-  module Model
-    # 
-    class RankingParams
-      attr_accessor :view
-      
-
-      attr_accessor :entity_type
-      
-
-      attr_accessor :ids
-      
-
-      attr_accessor :scope
-      
-
-      attr_accessor :ip
-      
-
-      attr_accessor :user_agent
-      
-
-      attr_accessor :customer
-      
-
-      attr_accessor :anonymous
-      
-
-      # :internal => :external
-      def self.attribute_map
-        {
-          :view => :view,
-          :entity_type => :entityType,
-          :ids => :ids,
-          :scope => :scope,
-          :ip => :ip,
-          :user_agent => :userAgent,
-          :customer => :customer,
-          :anonymous => :anonymous
-
-        }
-      end
-
-      def initialize(attributes = {})
-        return if attributes.empty?
-        # Morph attribute keys into undescored rubyish style
-        if self.class.attribute_map[:"view"]
-          # Workaround since JSON.parse has accessors as strings rather than symbols
-            @view = attributes["view"] || attributes[:"view"]
-        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[:"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.map{ |v| ScopeEntry.new(v) }
-
-            end
-          end
-        if self.class.attribute_map[:"ip"]
-          # Workaround since JSON.parse has accessors as strings rather than symbols
-            @ip = attributes["ip"] || attributes[:"ip"]
-        end
-        if self.class.attribute_map[:"user_agent"]
-          # Workaround since JSON.parse has accessors as strings rather than symbols
-            @user_agent = attributes["userAgent"] || attributes[:"user_agent"]
-        end
-        if self.class.attribute_map[:"customer"]
-          # Workaround since JSON.parse has accessors as strings rather than symbols
-            @customer = attributes["customer"] || attributes[:"customer"]
-        end
-        if self.class.attribute_map[:"anonymous"]
-          # Workaround since JSON.parse has accessors as strings rather than symbols
-            @anonymous = attributes["anonymous"] || attributes[:"anonymous"]
-        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/scopeentry.rb

@@ -1,49 +0,0 @@
-module Attune
-  module Model
-    # 
-    class ScopeEntry
-      attr_accessor :name
-      
-
-      attr_accessor :value
-      
-
-      # :internal => :external
-      def self.attribute_map
-        {
-          :name => :name,
-          :value => :value
-
-        }
-      end
-
-      def initialize(attributes = {})
-        return if attributes.empty?
-        # Morph attribute keys into undescored rubyish style
-        if self.class.attribute_map[:"name"]
-          # Workaround since JSON.parse has accessors as strings rather than symbols
-            @name = attributes["name"] || attributes[:"name"]
-        end
-        if self.class.attribute_map[:"value"]
-          # Workaround since JSON.parse has accessors as strings rather than symbols
-            @value = attributes["value"] || attributes[:"value"]
-        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
-