simplyrets 0.1

data/lib/simplyrets.rb~

@@ -0,0 +1,85 @@
+
+require 'monkey'
+require 'simplyrets/configuration'
+require 'simplyrets/request'
+require 'simplyrets/response'
+require 'simplyrets/version'
+require 'logger'
+
+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 = '1234567890abcdef'     # required
+    #     config.username = 'wordlover'           # optional, but needed for user-related functions
+    #     config.password = 'i<3words'            # optional, but needed for user-related functions
+    #     config.format = 'json'                  # optional, defaults to 'json'
+    #   end
+    #
+    def configure
+      self.configuration ||= Configuration.new
+      yield(configuration) if block_given?
+
+      # Configure logger.  Default to use Rails
+      self.logger ||= configuration.logger || (defined?(Rails) ? Rails.logger : Logger.new(STDOUT))
+
+      # 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.present?
+    end
+
+    def de_authenticate
+      SimplyRets.configuration.auth_token = nil
+    end
+
+    def authenticate
+      return if SimplyRets.authenticated?
+
+      if SimplyRets.configuration.username.blank? || SimplyRets.configuration.password.blank?
+        raise ClientError, "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
+
+  end
+
+end
+
+class ServerError < StandardError
+end
+
+class ClientError < StandardError
+end

data/lib/simplyrets/configuration.rb

@@ -0,0 +1,25 @@
+module SimplyRets
+
+  class Configuration
+    require 'simplyrets/version'
+
+    attr_accessor :format, :api_key, :username, :password,
+                  :auth_token, :scheme, :host, :base_path,
+                  :user_agent, :logger, :inject_format,
+                  :force_ending_format, :camelize_params
+
+    # Defaults go in here..
+    def initialize
+      @format = 'json'
+      @scheme = 'https'
+      @host = 'api.simplyrets.com'
+      @base_path = '/'
+      @user_agent = "ruby-#{SimplyRets::VERSION}"
+      @inject_format = false
+      @force_ending_format = false
+      @camelize_params = true
+    end
+
+  end
+
+end

data/lib/simplyrets/request.rb

@@ -0,0 +1,205 @@
+module SimplyRets
+
+  class Request
+    require 'uri'
+    require 'addressable/uri'
+    require 'typhoeus'
+    require 'base64'
+    require "simplyrets/version"
+
+    attr_accessor :host, :path, :format, :params, :body, :http_method, :headers
+
+
+    # All requests must have an HTTP method and a path
+    # Optionals parameters are :params, :headers, :body, :format, :host
+    #
+    def initialize(http_method, path, attributes={})
+      attributes[:format] ||= SimplyRets.configuration.format
+      attributes[:params] ||= {}
+
+      # Set default headers
+      default_headers = {
+        'Content-Type' => "application/#{attributes[:format].downcase}",
+        :api_key => SimplyRets.configuration.api_key
+      }
+
+      # api_key from headers hash trumps the default, even if its value is blank
+      if attributes[:headers].present? && attributes[:headers].has_key?(:api_key)
+        default_headers.delete(:api_key)
+      end
+
+      # api_key from params hash trumps all others (headers and default_headers)
+      if attributes[:params].present? && attributes[:params].has_key?(:api_key)
+        default_headers.delete(:api_key)
+        attributes[:headers].delete(:api_key) if attributes[:headers].present?
+      end
+
+      # Merge argument headers into defaults
+      attributes[:headers] = default_headers.merge(attributes[:headers] || {})
+
+      # Stick in the auth header
+      auth = SimplyRets.configuration.username + ":" + SimplyRets.configuration.password
+      attributes[:headers].merge!({"Authorization" =>
+          ("Basic " + Base64.encode64(auth))})
+
+      self.http_method = http_method.to_sym
+      self.path = path
+      attributes.each do |name, value|
+        send("#{name.to_s.underscore.to_sym}=", value)
+      end
+    end
+
+    # Construct a base URL
+    #
+    def url(options = {})
+      u = Addressable::URI.new(
+        :scheme => SimplyRets.configuration.scheme,
+        :host => SimplyRets.configuration.host,
+        :path => self.interpreted_path,
+        :query => self.query_string.sub(/\?/, '')
+      ).to_s
+
+      # Drop trailing question mark, if present
+      u.sub! /\?$/, ''
+
+      u
+    end
+
+    # Iterate over the params hash, injecting any path values into the path string
+    #
+    # NOTE: This is currently not supported in the SimplyRETS API. Content
+    # formatting is handled via the accept header.
+    #
+    # e.g. /properties.{format}/{word}/entries => /word.json/cat/entries
+    def interpreted_path
+      p = self.path.dup
+
+      # Fill in the path params
+      self.params.each_pair do |key, value|
+        p = p.gsub("{#{key}}", value.to_s)
+      end
+
+      # Stick a .{format} placeholder into the path if there isn't
+      # one already or an actual format like json or xml
+      # e.g. /properties/mlsId => /properties.{format}/mlsId
+      if SimplyRets.configuration.inject_format
+        unless ['.json', '.xml', '{format}'].any? {|s| p.downcase.include? s }
+          p = p.sub(/^(\/?\w+)/, "\\1.#{format}")
+        end
+      end
+
+      # Stick a .{format} placeholder on the end of the path if there
+      # isn't one already or an actual format like json or xml
+      #
+      # NOTE: This is currently not supported in the SimplyRETS
+      # API. Content formatting is handled via the accept header.
+      #
+      # e.g. /properties/blah => /properties/blah.{format}
+      if SimplyRets.configuration.force_ending_format
+        unless ['.json', '.xml', '{format}'].any? {|s| p.downcase.include? s }
+          p = "#{p}.#{format}"
+        end
+      end
+
+      p = p.sub("{format}", self.format.to_s)
+
+      URI.encode [SimplyRets.configuration.base_path, p].join("/").gsub(/\/+/, '/')
+    end
+
+    # Massage the request body into a state of readiness If body is a
+    # hash, camelize all keys then convert to a json string
+    def body=(value)
+      if value.is_a?(Hash)
+        value = value.inject({}) do |memo, (k,v)|
+          memo[k.to_s.camelize(:lower).to_sym] = v
+          memo
+        end
+      end
+      @body = value
+    end
+
+    # If body is an object, JSONify it before making the actual request.
+    #
+    def outgoing_body
+      body.is_a?(String) ? body : body.to_json
+    end
+
+    # Construct a query string from the query-string-type params
+    def query_string
+
+      # Iterate over all params,
+      # .. removing the ones that are part of the path itself.
+      # .. stringifying values so Addressable doesn't blow up.
+      query_values = {}
+      self.params.each_pair do |key, value|
+        next if self.path.include? "{#{key}}"               # skip path params
+        next if value.blank? && value.class != FalseClass   # skip empties
+        if SimplyRets.configuration.camelize_params
+          # api_key is not a camelCased param
+          #
+          # NOTE: api_key param is not currently used by SimplyRETS API
+          key = key.to_s.camelize(:lower).to_sym unless key.to_sym == :api_key
+        end
+        query_values[key] = value
+      end
+
+      # We don't want to end up with '?' as our query string
+      # if there aren't really any params
+      return "" if query_values.blank?
+
+      # Addressable requires query_values to be set after initialization..
+      qs = Addressable::URI.new
+      qs.query_values = query_values
+      qs.to_s
+    end
+
+    def make
+      logger = Logger.new STDOUT
+      logger.debug self.url
+      response = case self.http_method.to_sym
+      when :get,:GET
+        Typhoeus::Request.get(
+          self.url,
+          :headers => self.headers.stringify_keys,
+        )
+
+      when :post,:POST
+        Typhoeus::Request.post(
+          self.url,
+          :body => self.outgoing_body,
+          :headers => self.headers.stringify_keys,
+        )
+
+      when :put,:PUT
+        Typhoeus::Request.put(
+          self.url,
+          :body => self.outgoing_body,
+          :headers => self.headers.stringify_keys,
+        )
+
+      when :delete,:DELETE
+        Typhoeus::Request.delete(
+          self.url,
+          :body => self.outgoing_body,
+          :headers => self.headers.stringify_keys,
+        )
+      end
+      Response.new(response)
+    end
+
+    def response
+      self.make
+    end
+
+    def response_code_pretty
+      return unless @response.present?
+      @response.code.to_s
+    end
+
+    def response_headers_pretty
+      return unless @response.present?
+      @response.headers.gsub(/\n/, '<br/>') # <- This is for Typhoeus
+    end
+
+  end
+end

data/lib/simplyrets/response.rb

@@ -0,0 +1,70 @@
+module SimplyRets
+
+  class Response
+    require 'json'
+
+    attr_accessor :raw
+
+    def initialize(raw)
+      self.raw = raw
+
+      case self.code
+      when 500..510 then raise(ServerError, self.error_message)
+      when 299..426 then raise(ClientError, self.error_message)
+      end
+    end
+
+    def code
+      raw.code
+    end
+
+    # Account for error messages that take different forms...
+    def error_message
+      body['message']
+    rescue
+      body
+    end
+
+    # If body is JSON, parse it
+    # Otherwise return raw string
+    def body
+      JSON.parse raw.body
+    rescue
+      raw.body
+    end
+
+    # `headers_hash` is a Typhoeus-specific extension of Hash,
+    # so simplify it back into a regular old Hash.
+    def headers
+      h = {}
+      raw.headers_hash.each {|k,v| h[k] = v }
+      h
+    end
+
+    # Extract the response format from the header hash
+    # e.g. {'Content-Type' => 'application/json'}
+    def format
+      headers['Content-Type'].split("/").last.downcase
+    end
+
+    def json?
+      format == 'json'
+    end
+
+    def xml?
+      format == 'xml'
+    end
+
+    def pretty_body
+      return unless body.present?
+      case format
+      when 'json' then JSON.pretty_generate(body).gsub(/\n/, '<br/>')
+      end
+    end
+
+    def pretty_headers
+      JSON.pretty_generate(headers).gsub(/\n/, '<br/>')
+    end
+
+  end
+end

data/lib/simplyrets/version.rb

@@ -0,0 +1,4 @@
+module SimplyRets
+  VERSION = "0.1"
+end
+

data/models/agent.rb

@@ -0,0 +1,39 @@
+class Agent
+  attr_accessor :last_name, :contact, :first_name, :id
+
+  # :internal => :external
+  def self.attribute_map
+    {
+      :last_name => :lastName,
+      :contact => :contact,
+      :first_name => :firstName,
+      :id => :id
+
+    }
+  end
+
+  def initialize(attributes = {})
+    return if attributes.empty?
+    # Morph attribute keys into undescored rubyish style
+    if self.class.attribute_map[:"last_name"]
+      @last_name = attributes["lastName"]
+    end
+    if self.class.attribute_map[:"contact"]
+      @contact = attributes["contact"]
+    end
+    if self.class.attribute_map[:"first_name"]
+      @first_name = attributes["firstName"]
+    end
+    if self.class.attribute_map[:"id"]
+      @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
+end

data/models/contactinformation.rb

@@ -0,0 +1,36 @@
+class ContactInformation
+  attr_accessor :office, :cell, :full
+
+  # :internal => :external
+  def self.attribute_map
+    {
+      :office => :office,
+      :cell => :cell,
+      :full => :full
+
+    }
+  end
+
+  def initialize(attributes = {})
+    return if attributes.empty?
+    # Morph attribute keys into undescored rubyish style
+    if self.class.attribute_map[:"office"]
+      @office = attributes["office"]
+    end
+    if self.class.attribute_map[:"cell"]
+      @cell = attributes["cell"]
+    end
+    if self.class.attribute_map[:"full"]
+      @full = attributes["full"]
+    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
+end