subtledata 0.0.2 → 0.0.3

data/lib/subtledata.rb

@@ -0,0 +1,26 @@
+
+models = File.join(File.dirname(__FILE__), '..', 'models', '*.rb')
+Dir[models].each {|file| require file }
+
+require_relative './general_api.rb'
+require_relative './locations_api.rb'
+require_relative './monkey.rb'
+require_relative './swagger.rb'
+require_relative './users_api.rb'
+
+Swagger.configure do |config|
+    config.format = 'json'
+    config.scheme = 'https'
+    config.host = 'api.subtledata.com'
+    config.base_path = '/v1'
+    config.inject_format = false
+end
+
+module SubtleData
+    module Standard
+        Locations = ::Locations_api
+        Users = ::Users_api
+        General = ::General_api
+    end
+end
+

data/lib/swagger/configuration.rb

@@ -3,7 +3,7 @@ module Swagger
   class Configuration
     require 'swagger/version'    
     
-    attr_accessor :format, :api_key, :username, :password, :auth_token, :scheme, :host, :base_path, :user_agent, :logger
+    attr_accessor :format, :api_key, :username, :password, :auth_token, :scheme, :host, :base_path, :user_agent, :logger, :inject_format
     
     # Defaults go in here..
     def initialize
@@ -12,6 +12,7 @@ module Swagger
       @host = 'api.wordnik.com'
       @base_path = '/v4'
       @user_agent = "ruby-#{Swagger::VERSION}"
+      @inject_format = true
     end
 
   end

data/lib/swagger/request.rb

@@ -81,8 +81,10 @@ module Swagger
       # Stick a .{format} placeholder into the path if there isn't
       # one already or an actual format like json or xml
       # e.g. /words/blah => /words.{format}/blah
-      unless ['.json', '.xml', '{format}'].any? {|s| p.downcase.include? s }
-        p = p.sub(/^(\/?\w+)/, "\\1.#{format}")
+      if Swagger.configuration.inject_format
+        unless ['.json', '.xml', '{format}'].any? {|s| p.downcase.include? s }
+          p = p.sub(/^(\/?\w+)/, "\\1.#{format}")
+        end
       end
 
       p = p.sub("{format}", self.format.to_s)

data/models/authresponse.rb

@@ -0,0 +1,52 @@
+class AuthResponse
+  attr_accessor :device_id, :user_id, :result, :success, :error
+
+  # :internal => :external
+  def self.attribute_map
+  {
+      :device_id => :device_id, :user_id => :user_id, :result => :result, :success => :success, :error => :error
+
+  }
+  end
+
+  def initialize(attributes = {})
+    # Morph attribute keys into undescored rubyish style
+    if attributes.to_s != ""
+
+      if AuthResponse.attribute_map["device_id".to_sym] != nil
+        name = "device_id".to_sym
+        value = attributes["device_id"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if AuthResponse.attribute_map["user_id".to_sym] != nil
+        name = "user_id".to_sym
+        value = attributes["user_id"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if AuthResponse.attribute_map["result".to_sym] != nil
+        name = "result".to_sym
+        value = attributes["result"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if AuthResponse.attribute_map["success".to_sym] != nil
+        name = "success".to_sym
+        value = attributes["success"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if AuthResponse.attribute_map["error".to_sym] != nil
+        name = "error".to_sym
+        value = attributes["error"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      end
+  end
+
+  def to_body
+    body = {}
+    AuthResponse.attribute_map.each_pair do |key,value|
+      body[value] = self.send(key) unless self.send(key).nil?
+    end
+    body
+  end
+end
+

data/models/authuserrequest.rb

@@ -0,0 +1,57 @@
+class AuthUserRequest
+  attr_accessor :username, :user_id, :device_uuid, :longitude, :latitude, :password
+
+  # :internal => :external
+  def self.attribute_map
+  {
+      :username => :username, :user_id => :user_id, :device_uuid => :device_uuid, :longitude => :longitude, :latitude => :latitude, :password => :password
+
+  }
+  end
+
+  def initialize(attributes = {})
+    # Morph attribute keys into undescored rubyish style
+    if attributes.to_s != ""
+
+      if AuthUserRequest.attribute_map["username".to_sym] != nil
+        name = "username".to_sym
+        value = attributes["username"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if AuthUserRequest.attribute_map["user_id".to_sym] != nil
+        name = "user_id".to_sym
+        value = attributes["user_id"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if AuthUserRequest.attribute_map["device_uuid".to_sym] != nil
+        name = "device_uuid".to_sym
+        value = attributes["device_uuid"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if AuthUserRequest.attribute_map["longitude".to_sym] != nil
+        name = "longitude".to_sym
+        value = attributes["longitude"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if AuthUserRequest.attribute_map["latitude".to_sym] != nil
+        name = "latitude".to_sym
+        value = attributes["latitude"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if AuthUserRequest.attribute_map["password".to_sym] != nil
+        name = "password".to_sym
+        value = attributes["password"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      end
+  end
+
+  def to_body
+    body = {}
+    AuthUserRequest.attribute_map.each_pair do |key,value|
+      body[value] = self.send(key) unless self.send(key).nil?
+    end
+    body
+  end
+end
+

data/models/card.rb

@@ -0,0 +1,62 @@
+class Card
+  attr_accessor :name_on_card, :card_type, :expiration_year, :card_id, :expiration_month, :nickname, :last_4_digits
+
+  # :internal => :external
+  def self.attribute_map
+  {
+      :name_on_card => :name_on_card, :card_type => :card_type, :expiration_year => :expiration_year, :card_id => :card_id, :expiration_month => :expiration_month, :nickname => :nickname, :last_4_digits => :last_4_digits
+
+  }
+  end
+
+  def initialize(attributes = {})
+    # Morph attribute keys into undescored rubyish style
+    if attributes.to_s != ""
+
+      if Card.attribute_map["name_on_card".to_sym] != nil
+        name = "name_on_card".to_sym
+        value = attributes["name_on_card"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if Card.attribute_map["card_type".to_sym] != nil
+        name = "card_type".to_sym
+        value = attributes["card_type"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if Card.attribute_map["expiration_year".to_sym] != nil
+        name = "expiration_year".to_sym
+        value = attributes["expiration_year"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if Card.attribute_map["card_id".to_sym] != nil
+        name = "card_id".to_sym
+        value = attributes["card_id"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if Card.attribute_map["expiration_month".to_sym] != nil
+        name = "expiration_month".to_sym
+        value = attributes["expiration_month"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if Card.attribute_map["nickname".to_sym] != nil
+        name = "nickname".to_sym
+        value = attributes["nickname"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if Card.attribute_map["last_4_digits".to_sym] != nil
+        name = "last_4_digits".to_sym
+        value = attributes["last_4_digits"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      end
+  end
+
+  def to_body
+    body = {}
+    Card.attribute_map.each_pair do |key,value|
+      body[value] = self.send(key) unless self.send(key).nil?
+    end
+    body
+  end
+end
+

data/models/cardstatus.rb

@@ -0,0 +1,47 @@
+class CardStatus
+  attr_accessor :card_id, :result, :success, :error
+
+  # :internal => :external
+  def self.attribute_map
+  {
+      :card_id => :card_id, :result => :result, :success => :success, :error => :error
+
+  }
+  end
+
+  def initialize(attributes = {})
+    # Morph attribute keys into undescored rubyish style
+    if attributes.to_s != ""
+
+      if CardStatus.attribute_map["card_id".to_sym] != nil
+        name = "card_id".to_sym
+        value = attributes["card_id"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if CardStatus.attribute_map["result".to_sym] != nil
+        name = "result".to_sym
+        value = attributes["result"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if CardStatus.attribute_map["success".to_sym] != nil
+        name = "success".to_sym
+        value = attributes["success"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if CardStatus.attribute_map["error".to_sym] != nil
+        name = "error".to_sym
+        value = attributes["error"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      end
+  end
+
+  def to_body
+    body = {}
+    CardStatus.attribute_map.each_pair do |key,value|
+      body[value] = self.send(key) unless self.send(key).nil?
+    end
+    body
+  end
+end
+

data/models/category.rb

@@ -0,0 +1,74 @@
+class Category
+  attr_accessor :items, :has_items, :instructional_text, :category_images, :category_id, :has_subcategories, :category_name
+
+  # :internal => :external
+  def self.attribute_map
+  {
+      :items => :items, :has_items => :has_items, :instructional_text => :instructional_text, :category_images => :category_images, :category_id => :category_id, :has_subcategories => :has_subcategories, :category_name => :category_name
+
+  }
+  end
+
+  def initialize(attributes = {})
+    # Morph attribute keys into undescored rubyish style
+    if attributes.to_s != ""
+
+      if Category.attribute_map["items".to_sym] != nil
+        name = "items".to_sym
+        value = attributes["items"]
+        if value.is_a?(Array)
+	        array = Array.new
+	        value.each do |arrayValue|
+	          array.push Item.new(arrayValue)
+	        end
+	        send("#{name}=", array) if self.respond_to?(name)
+	      end
+        end
+      if Category.attribute_map["has_items".to_sym] != nil
+        name = "has_items".to_sym
+        value = attributes["has_items"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if Category.attribute_map["instructional_text".to_sym] != nil
+        name = "instructional_text".to_sym
+        value = attributes["instructional_text"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if Category.attribute_map["category_images".to_sym] != nil
+        name = "category_images".to_sym
+        value = attributes["category_images"]
+        if value.is_a?(Array)
+	        array = Array.new
+	        value.each do |arrayValue|
+	          array.push CategoryImage.new(arrayValue)
+	        end
+	        send("#{name}=", array) if self.respond_to?(name)
+	      end
+        end
+      if Category.attribute_map["category_id".to_sym] != nil
+        name = "category_id".to_sym
+        value = attributes["category_id"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if Category.attribute_map["has_subcategories".to_sym] != nil
+        name = "has_subcategories".to_sym
+        value = attributes["has_subcategories"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if Category.attribute_map["category_name".to_sym] != nil
+        name = "category_name".to_sym
+        value = attributes["category_name"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      end
+  end
+
+  def to_body
+    body = {}
+    Category.attribute_map.each_pair do |key,value|
+      body[value] = self.send(key) unless self.send(key).nil?
+    end
+    body
+  end
+end
+

data/models/categoryimage.rb

@@ -0,0 +1,37 @@
+class CategoryImage
+  attr_accessor :image_url, :image_type_id
+
+  # :internal => :external
+  def self.attribute_map
+  {
+      :image_url => :image_url, :image_type_id => :image_type_id
+
+  }
+  end
+
+  def initialize(attributes = {})
+    # Morph attribute keys into undescored rubyish style
+    if attributes.to_s != ""
+
+      if CategoryImage.attribute_map["image_url".to_sym] != nil
+        name = "image_url".to_sym
+        value = attributes["image_url"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if CategoryImage.attribute_map["image_type_id".to_sym] != nil
+        name = "image_type_id".to_sym
+        value = attributes["image_type_id"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      end
+  end
+
+  def to_body
+    body = {}
+    CategoryImage.attribute_map.each_pair do |key,value|
+      body[value] = self.send(key) unless self.send(key).nil?
+    end
+    body
+  end
+end
+

data/models/connecteduser.rb

@@ -0,0 +1,72 @@
+class ConnectedUser
+  attr_accessor :first_name, :last_name, :user_id, :dob, :email_address, :cover_number, :middle_name, :cell_phone, :user_name
+
+  # :internal => :external
+  def self.attribute_map
+  {
+      :first_name => :first_name, :last_name => :last_name, :user_id => :user_id, :dob => :dob, :email_address => :email_address, :cover_number => :cover_number, :middle_name => :middle_name, :cell_phone => :cell_phone, :user_name => :user_name
+
+  }
+  end
+
+  def initialize(attributes = {})
+    # Morph attribute keys into undescored rubyish style
+    if attributes.to_s != ""
+
+      if ConnectedUser.attribute_map["first_name".to_sym] != nil
+        name = "first_name".to_sym
+        value = attributes["first_name"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if ConnectedUser.attribute_map["last_name".to_sym] != nil
+        name = "last_name".to_sym
+        value = attributes["last_name"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if ConnectedUser.attribute_map["user_id".to_sym] != nil
+        name = "user_id".to_sym
+        value = attributes["user_id"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if ConnectedUser.attribute_map["dob".to_sym] != nil
+        name = "dob".to_sym
+        value = attributes["dob"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if ConnectedUser.attribute_map["email_address".to_sym] != nil
+        name = "email_address".to_sym
+        value = attributes["email_address"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if ConnectedUser.attribute_map["cover_number".to_sym] != nil
+        name = "cover_number".to_sym
+        value = attributes["cover_number"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if ConnectedUser.attribute_map["middle_name".to_sym] != nil
+        name = "middle_name".to_sym
+        value = attributes["middle_name"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if ConnectedUser.attribute_map["cell_phone".to_sym] != nil
+        name = "cell_phone".to_sym
+        value = attributes["cell_phone"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if ConnectedUser.attribute_map["user_name".to_sym] != nil
+        name = "user_name".to_sym
+        value = attributes["user_name"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      end
+  end
+
+  def to_body
+    body = {}
+    ConnectedUser.attribute_map.each_pair do |key,value|
+      body[value] = self.send(key) unless self.send(key).nil?
+    end
+    body
+  end
+end
+

data/models/connectstatus.rb

@@ -0,0 +1,42 @@
+class ConnectStatus
+  attr_accessor :result, :success, :error
+
+  # :internal => :external
+  def self.attribute_map
+  {
+      :result => :result, :success => :success, :error => :error
+
+  }
+  end
+
+  def initialize(attributes = {})
+    # Morph attribute keys into undescored rubyish style
+    if attributes.to_s != ""
+
+      if ConnectStatus.attribute_map["result".to_sym] != nil
+        name = "result".to_sym
+        value = attributes["result"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if ConnectStatus.attribute_map["success".to_sym] != nil
+        name = "success".to_sym
+        value = attributes["success"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if ConnectStatus.attribute_map["error".to_sym] != nil
+        name = "error".to_sym
+        value = attributes["error"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      end
+  end
+
+  def to_body
+    body = {}
+    ConnectStatus.attribute_map.each_pair do |key,value|
+      body[value] = self.send(key) unless self.send(key).nil?
+    end
+    body
+  end
+end
+

data/models/country.rb

@@ -0,0 +1,37 @@
+class Country
+  attr_accessor :country_name, :country_id
+
+  # :internal => :external
+  def self.attribute_map
+  {
+      :country_name => :country_name, :country_id => :country_id
+
+  }
+  end
+
+  def initialize(attributes = {})
+    # Morph attribute keys into undescored rubyish style
+    if attributes.to_s != ""
+
+      if Country.attribute_map["country_name".to_sym] != nil
+        name = "country_name".to_sym
+        value = attributes["country_name"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if Country.attribute_map["country_id".to_sym] != nil
+        name = "country_id".to_sym
+        value = attributes["country_id"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      end
+  end
+
+  def to_body
+    body = {}
+    Country.attribute_map.each_pair do |key,value|
+      body[value] = self.send(key) unless self.send(key).nil?
+    end
+    body
+  end
+end
+

data/models/deleteuserstatus.rb

@@ -0,0 +1,42 @@
+class DeleteUserStatus
+  attr_accessor :result, :success, :error
+
+  # :internal => :external
+  def self.attribute_map
+  {
+      :result => :result, :success => :success, :error => :error
+
+  }
+  end
+
+  def initialize(attributes = {})
+    # Morph attribute keys into undescored rubyish style
+    if attributes.to_s != ""
+
+      if DeleteUserStatus.attribute_map["result".to_sym] != nil
+        name = "result".to_sym
+        value = attributes["result"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if DeleteUserStatus.attribute_map["success".to_sym] != nil
+        name = "success".to_sym
+        value = attributes["success"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if DeleteUserStatus.attribute_map["error".to_sym] != nil
+        name = "error".to_sym
+        value = attributes["error"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      end
+  end
+
+  def to_body
+    body = {}
+    DeleteUserStatus.attribute_map.each_pair do |key,value|
+      body[value] = self.send(key) unless self.send(key).nil?
+    end
+    body
+  end
+end
+

data/models/discountinfo.rb

@@ -0,0 +1,42 @@
+class DiscountInfo
+  attr_accessor :discount_type, :user_id, :discount_amount
+
+  # :internal => :external
+  def self.attribute_map
+  {
+      :discount_type => :discount_type, :user_id => :user_id, :discount_amount => :discount_amount
+
+  }
+  end
+
+  def initialize(attributes = {})
+    # Morph attribute keys into undescored rubyish style
+    if attributes.to_s != ""
+
+      if DiscountInfo.attribute_map["discount_type".to_sym] != nil
+        name = "discount_type".to_sym
+        value = attributes["discount_type"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if DiscountInfo.attribute_map["user_id".to_sym] != nil
+        name = "user_id".to_sym
+        value = attributes["user_id"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if DiscountInfo.attribute_map["discount_amount".to_sym] != nil
+        name = "discount_amount".to_sym
+        value = attributes["discount_amount"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      end
+  end
+
+  def to_body
+    body = {}
+    DiscountInfo.attribute_map.each_pair do |key,value|
+      body[value] = self.send(key) unless self.send(key).nil?
+    end
+    body
+  end
+end
+

data/models/discounttype.rb

@@ -0,0 +1,42 @@
+class DiscountType
+  attr_accessor :default_discount, :discount_type_id, :name
+
+  # :internal => :external
+  def self.attribute_map
+  {
+      :default_discount => :default_discount, :discount_type_id => :discount_type_id, :name => :name
+
+  }
+  end
+
+  def initialize(attributes = {})
+    # Morph attribute keys into undescored rubyish style
+    if attributes.to_s != ""
+
+      if DiscountType.attribute_map["default_discount".to_sym] != nil
+        name = "default_discount".to_sym
+        value = attributes["default_discount"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if DiscountType.attribute_map["discount_type_id".to_sym] != nil
+        name = "discount_type_id".to_sym
+        value = attributes["discount_type_id"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      if DiscountType.attribute_map["name".to_sym] != nil
+        name = "name".to_sym
+        value = attributes["name"]
+        send("#{name}=", value) if self.respond_to?(name)
+	      end
+      end
+  end
+
+  def to_body
+    body = {}
+    DiscountType.attribute_map.each_pair do |key,value|
+      body[value] = self.send(key) unless self.send(key).nil?
+    end
+    body
+  end
+end
+