simplyrets 0.1 → 1.0.0

data/lib/simplyrets/models/sales.rb

@@ -0,0 +1,69 @@
+module SimplyRetsClient
+  #
+  class Sales < BaseObject
+    attr_accessor :agent, :close_date, :close_price, :contract_date, :office
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+
+        # RETS Sales data agent id
+        :'agent' => :'agent',
+
+        # RETS Sales data close date
+        :'close_date' => :'closeDate',
+
+        # RETS Sales data sold price
+        :'close_price' => :'closePrice',
+
+        # RETS Sales data contract date
+        :'contract_date' => :'contractDate',
+
+        # RETS Sales data selling office/brokerage id
+        :'office' => :'office'
+
+      }
+    end
+
+    # attribute type
+    def self.simplyrets_types
+      {
+        :'agent' => :'String',
+        :'close_date' => :'DateTime',
+        :'close_price' => :'Integer',
+        :'contract_date' => :'DateTime',
+        :'office' => :'String'
+
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+
+      if attributes[:'agent']
+        self.agent = attributes[:'agent']
+      end
+
+      if attributes[:'closeDate']
+        self.close_date = attributes[:'closeDate']
+      end
+
+      if attributes[:'closePrice']
+        self.close_price = attributes[:'closePrice']
+      end
+
+      if attributes[:'contractDate']
+        self.contract_date = attributes[:'contractDate']
+      end
+
+      if attributes[:'office']
+        self.office = attributes[:'office']
+      end
+
+    end
+
+  end
+end

data/lib/simplyrets/models/school.rb

@@ -0,0 +1,61 @@
+module SimplyRetsClient
+  #
+  class School < BaseObject
+    attr_accessor :district, :elementary_school, :middle_school, :high_school
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+
+        # School district name.
+        :'district' => :'district',
+
+        # Elementary school name.
+        :'elementary_school' => :'elementarySchool',
+
+        # Middle or junior school name
+        :'middle_school' => :'middleSchool',
+
+        # High school name
+        :'high_school' => :'highSchool'
+
+      }
+    end
+
+    # attribute type
+    def self.simplyrets_types
+      {
+        :'district' => :'String',
+        :'elementary_school' => :'String',
+        :'middle_school' => :'String',
+        :'high_school' => :'String'
+
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+
+      if attributes[:'district']
+        self.district = attributes[:'district']
+      end
+
+      if attributes[:'elementarySchool']
+        self.elementary_school = attributes[:'elementarySchool']
+      end
+
+      if attributes[:'middleSchool']
+        self.middle_school = attributes[:'middleSchool']
+      end
+
+      if attributes[:'highSchool']
+        self.high_school = attributes[:'highSchool']
+      end
+
+    end
+
+  end
+end

data/lib/simplyrets/models/street_address.rb

@@ -0,0 +1,85 @@
+module SimplyRetsClient
+  #
+  class StreetAddress < BaseObject
+    attr_accessor :country, :postal_code, :street_name, :city, :street_number, :full, :cross_street
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+
+        # Street address country (United States or Canada)
+        :'country' => :'country',
+
+        # Street Address postal code
+        :'postal_code' => :'postalCode',
+
+        # Name of the street
+        :'street_name' => :'streetName',
+
+        # City name
+        :'city' => :'city',
+
+        # Street number
+        :'street_number' => :'streetNumber',
+
+        # Full pretty-printed address with suffix (if available)
+        :'full' => :'full',
+
+        # Known cross street
+        :'cross_street' => :'crossStreet'
+
+      }
+    end
+
+    # attribute type
+    def self.simplyrets_types
+      {
+        :'country' => :'String',
+        :'postal_code' => :'String',
+        :'street_name' => :'String',
+        :'city' => :'String',
+        :'street_number' => :'Integer',
+        :'full' => :'String',
+        :'cross_street' => :'String'
+
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+
+      if attributes[:'country']
+        self.country = attributes[:'country']
+      end
+
+      if attributes[:'postalCode']
+        self.postal_code = attributes[:'postalCode']
+      end
+
+      if attributes[:'streetName']
+        self.street_name = attributes[:'streetName']
+      end
+
+      if attributes[:'city']
+        self.city = attributes[:'city']
+      end
+
+      if attributes[:'streetNumber']
+        self.street_number = attributes[:'streetNumber']
+      end
+
+      if attributes[:'full']
+        self.full = attributes[:'full']
+      end
+
+      if attributes[:'crossStreet']
+        self.cross_street = attributes[:'crossStreet']
+      end
+
+    end
+
+  end
+end

data/lib/simplyrets/models/tax.rb

@@ -0,0 +1,53 @@
+module SimplyRetsClient
+  #
+  class Tax < BaseObject
+    attr_accessor :id, :annual_amount, :year
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+
+        # Tax Parcel ID for the listing
+        :'id' => :'id',
+
+        # Annual tax amount in USD
+        :'annual_amount' => :'annualAmount',
+
+        # Tax Year
+        :'year' => :'year'
+
+      }
+    end
+
+    # attribute type
+    def self.simplyrets_types
+      {
+        :'id' => :'String',
+        :'annual_amount' => :'String',
+        :'year' => :'Integer'
+
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+
+      if attributes[:'id']
+        self.id = attributes[:'id']
+      end
+
+      if attributes[:'annualAmount']
+        self.annual_amount = attributes[:'annualAmount']
+      end
+
+      if attributes[:'year']
+        self.year = attributes[:'year']
+      end
+
+    end
+
+  end
+end

data/lib/simplyrets/simplyrets.rb

@@ -0,0 +1,76 @@
+module SimplyRetsClient
+  module SimplyRets
+    class << self
+      attr_accessor :logger
+
+      # A SimplyRets configuration object. Must act like a hash and return sensible
+      # values for all SimplyRets configuration options. See SimplyRets::Configuration.
+      attr_accessor :configuration
+
+      attr_accessor :resources
+
+      # Call this method to modify defaults in your initializers.
+      #
+      # @example
+      #   SimplyRets.configure do |config|
+      #     config.api_key['api_key'] = '1234567890abcdef'     # api key authentication
+      #     config.username = 'wordlover'           # http basic authentication
+      #     config.password = 'i<3words'            # http basic authentication
+      #     config.format = 'json'                  # optional, defaults to 'json'
+      #   end
+      #
+      def configure
+        yield(configuration) if block_given?
+
+        self.logger = configuration.logger
+
+        # remove :// from scheme
+        configuration.scheme.sub!(/:\/\//, '')
+
+        # remove http(s):// and anything after a slash
+        configuration.host.sub!(/https?:\/\//, '')
+        configuration.host = configuration.host.split('/').first
+
+        # Add leading and trailing slashes to base_path
+        configuration.base_path = "/#{configuration.base_path}".gsub(/\/+/, '/')
+        configuration.base_path = "" if configuration.base_path == "/"
+      end
+
+      def authenticated?
+        !SimplyRets.configuration.auth_token.nil?
+      end
+
+      def de_authenticate
+        SimplyRets.configuration.auth_token = nil
+      end
+
+      def authenticate
+        return if SimplyRets.authenticated?
+
+        if SimplyRets.configuration.username.nil? || SimplyRets.configuration.password.nil?
+          raise ApiError, "Username and password are required to authenticate."
+        end
+
+        request = SimplyRets::Request.new(
+          :get,
+          "account/authenticate/{username}",
+          :params => {
+            :username => SimplyRets.configuration.username,
+            :password => SimplyRets.configuration.password
+          }
+        )
+
+        response_body = request.response.body
+        SimplyRets.configuration.auth_token = response_body['token']
+      end
+
+      def last_response
+        Thread.current[:simplyrets_last_response]
+      end
+
+      def last_response=(response)
+        Thread.current[:simplyrets_last_response] = response
+      end
+    end
+  end
+end

data/lib/simplyrets/simplyrets/api_error.rb

@@ -0,0 +1,26 @@
+module SimplyRetsClient
+  module SimplyRets
+    class ApiError < StandardError
+      attr_reader :code, :response_headers, :response_body
+
+      # Usage examples:
+      #   ApiError.new
+      #   ApiError.new("message")
+      #   ApiError.new(:code => 500, :response_headers => {}, :response_body => "")
+      #   ApiError.new(:code => 404, :message => "Not Found")
+      def initialize(arg = nil)
+        if arg.is_a? Hash
+          arg.each do |k, v|
+            if k.to_s == 'message'
+              super v
+            else
+              instance_variable_set "@#{k}", v
+            end
+          end
+        else
+          super arg
+        end
+      end
+    end
+  end
+end

data/lib/simplyrets/simplyrets/configuration.rb

@@ -0,0 +1,101 @@
+require 'logger'
+
+module SimplyRetsClient
+  module SimplyRets
+    class Configuration
+      attr_accessor :scheme, :host, :base_path, :user_agent, :format, :auth_token, :inject_format, :force_ending_format
+
+      # Defines the username used with HTTP basic authentication.
+      #
+      # @return [String]
+      attr_accessor :username
+
+      # Defines the password used with HTTP basic authentication.
+      #
+      # @return [String]
+      attr_accessor :password
+
+      # Defines API keys used with API Key authentications.
+      #
+      # @return [Hash] key: parameter name, value: parameter value (API key)
+      #
+      # @example parameter name is "api_key", API key is "xxx" (e.g. "api_key=xxx" in query string)
+      #   config.api_key['api_key'] = 'xxx'
+      attr_accessor :api_key
+
+      # Defines API key prefixes used with API Key authentications.
+      #
+      # @return [Hash] key: parameter name, value: API key prefix
+      #
+      # @example parameter name is "Authorization", API key prefix is "Token" (e.g. "Authorization: Token xxx" in headers)
+      #   config.api_key_prefix['api_key'] = 'Token'
+      attr_accessor :api_key_prefix
+
+      # Set this to false to skip verifying SSL certificate when calling API from https server.
+      # Default to true.
+      #
+      # @note Do NOT set it to false in production code, otherwise you would face multiple types of cryptographic attacks.
+      #
+      # @return [true, false]
+      attr_accessor :verify_ssl
+
+      # Set this to customize the certificate file to verify the peer.
+      #
+      # @return [String] the path to the certificate file
+      #
+      # @see The `cainfo` option of Typhoeus, `--cert` option of libcurl. Related source code:
+      # https://github.com/typhoeus/typhoeus/blob/master/lib/typhoeus/easy_factory.rb#L145
+      attr_accessor :ssl_ca_cert
+
+      # Set this to enable/disable debugging. When enabled (set to true), HTTP request/response
+      # details will be logged with `logger.debug` (see the `logger` attribute).
+      # Default to false.
+      #
+      # @return [true, false]
+      attr_accessor :debug
+
+      # Defines the logger used for debugging.
+      # Default to `Rails.logger` (when in Rails) or logging to STDOUT.
+      #
+      # @return [#debug]
+      attr_accessor :logger
+
+      # Defines the temporary folder to store downloaded files
+      # (for API endpoints that have file response).
+      # Default to use `Tempfile`.
+      #
+      # @return [String]
+      attr_accessor :temp_folder_path
+
+      # Defines the headers to be used in HTTP requests of all API calls by default.
+      #
+      # @return [Hash]
+      attr_accessor :default_headers
+
+      # Defaults go in here..
+      def initialize
+        @format = 'json'
+        @scheme = 'https'
+        @host = 'api.simplyrets.com'
+        @base_path = '/'
+        @user_agent = "ruby-simplyrets-#{SimplyRets::VERSION}"
+        @inject_format = false
+        @force_ending_format = false
+
+        @default_headers = {
+          'Content-Type' => "application/#{@format.downcase}",
+          'User-Agent' => @user_agent
+        }
+
+        # keys for API key authentication (param-name => api-key)
+        @api_key = {}
+        @api_key_prefix = {}
+
+        @verify_ssl = true
+
+        @debug = false
+        @logger = defined?(Rails) ? Rails.logger : Logger.new(STDOUT)
+      end
+    end
+  end
+end