mls 0.2.2 → 0.2.3

data/lib/mls/errors.rb

@@ -1,14 +1,23 @@
 class MLS::Exception < Exception
 end
 
-class MLS::BadRequest < MLS::Exception
+class MLS::Exception::UnexpectedResponse < MLS::Exception
 end
 
-class MLS::Unauthorized < MLS::Exception
+class MLS::Exception::BadRequest < MLS::Exception
 end
 
-class MLS::NotFound < MLS::Exception
+class MLS::Exception::Unauthorized < MLS::Exception
 end
 
-class MLS::ApiVersionUnsupported < MLS::Exception
+class MLS::Exception::NotFound < MLS::Exception
+end
+
+class MLS::Exception::ApiVersionUnsupported < MLS::Exception
+end
+
+class MLS::Exception::RecordInvalid < MLS::Exception
+end
+
+class MLS::Exception::ServiceUnavailable < MLS::Exception
 end

data/lib/mls/model.rb

@@ -1,23 +1,51 @@
 module MLS::Model
 
-  def self.extended(model)
+  def self.extended(model) #:nodoc:
     model.instance_variable_set(:@properties, {})
     model.instance_variable_set(:@associations, {})
   end
 
+  # Creates an object and saves it to the MLS. The resulting object is returned
+  # whether or no the object was saved successfully to the MLS or not.
+  #
+  # ==== Examples
+  #  #!ruby
+  #  # Create a single new object
+  #  User.create(:first_name => 'Jamie')
+  #  
+  #  # Create a single object and pass it into a block to set other attributes.
+  #  User.create(:first_name => 'Jamie') do |u|
+  #    u.is_admin = false
+  #  end
+  def create(attributes={}, &block) # TODO: testme
+    model = self.new(attributes)
+    yield(model) if block_given?
+    model.save
+    model
+  end
+
   # Properties ===================================================================================================
-  
+
   def property(name, type, options = {})
     klass = MLS::Property.determine_class(type)
     raise NotImplementedError, "#{type} is not supported" unless klass
 
     property = klass.new(name, options)
     @properties[property.name] = property
+    @properties_excluded_from_comparison = []
 
     create_reader_for(property)
     create_writer_for(property)
   end
 
+  def exclude_from_comparison(*properties)
+    @properties_excluded_from_comparison |= properties
+  end
+
+  def properties_excluded_from_comparison
+    @properties_excluded_from_comparison
+  end
+
   def properties
     @properties
   end
@@ -82,13 +110,16 @@ module MLS::Model
   end
   
   # used for parser
-  
+  def root_element_string
+    ActiveSupport::Inflector.demodulize(self).underscore
+  end
+
   def root_element
-    @root_element ||= ActiveSupport::Inflector.demodulize(self).downcase.to_sym
+    @root_element ||= root_element_string.to_sym
   end
   
   def collection_root_element
-    @collection_root_element ||= ActiveSupport::Inflector.demodulize(self).downcase.pluralize.to_sym
+    @collection_root_element ||= root_element_string.pluralize.to_sym
   end
   
 end

data/lib/mls/models/account.rb

@@ -4,6 +4,7 @@ class MLS::Account < MLS::Resource
   DEFAULTS = {:role => 'user'}
 
   property :id,                      Fixnum
+  property :type,                    String,   :default => 'User'
   property :role,                    String,   :default => 'user'
   property :name,                    String
   property :title,                   String
@@ -12,6 +13,7 @@ class MLS::Account < MLS::Resource
   property :password_confirmation,   String,   :serialize => :if_present
   property :perishable_token,        String
   property :perishable_token_set_at, String
+  property :ghost,                   Boolean,  :serialize => false, :default => false
   
   property :phone,                   String
   property :system_phone,            String
@@ -21,7 +23,7 @@ class MLS::Account < MLS::Resource
   property :twitter,                 String
   property :facebook,                String
   property :web,                     String
-  property :mls_number,              String
+  property :system_phone,            String
   
   property :city,                    String
   property :state,                   String
@@ -30,36 +32,33 @@ class MLS::Account < MLS::Resource
   property :auth_key,                String
 
   property :funding,                 String
-  property :message,                 String
   property :population,              String
   property :growing,                 Boolean
   property :move_in,                 String
   property :extra_info,              String
-  
-  def update!
-    MLS.put('/account', to_hash) do |code, response|
-      case code
-      when 400
-        @errors = MLS.parse(response.body)[:errors]
-        return false
-      else
-        MLS.handle_response(response)
-        MLS::Account::Parser.update(self, response.body)
-      end
+
+  exclude_from_comparison :password, :password_confirmation
+
+  attr_accessor :password_required
+
+  attr_writer :favorites
+
+  def update
+    MLS.put('/account', to_hash, 400) do |response, code|
+      MLS::Account::Parser.update(self, response.body)
+      code == 200
     end
   end
   
-  def create!
-    Rails.logger.warn(to_hash)
-    MLS.post('/account', to_hash) do |code, response|
-      case code
-      when 400
-        @errors = MLS.parse(response.body)[:errors]
-        return false
-      else
-        MLS.handle_response(response)
-        MLS::Account::Parser.update(self, response.body)
-      end
+  # Save the Account to the MLS. @errors will be set on the account if there
+  # are any errors. @persisted will also be set to +true+ if the Account was
+  # succesfully created
+  def create
+    MLS.post('/account', to_hash, 400) do |response, code|
+      raise MLS::Exception::UnexpectedResponse if ![201, 400].include?(code)
+      MLS::Account::Parser.update(self, response.body)
+      @persisted = true
+      code == 201
     end
   end
 
@@ -68,77 +67,82 @@ class MLS::Account < MLS::Resource
   end
 
   def favorites
+    return @favorites if @favorites
     response = MLS.get('/account/favorites')
-    MLS::Listing::Parser.parse_collection(response.body)
+    @favorites = MLS::Listing::Parser.parse_collection(response.body, {:collection_root_element => :favorites})
   end
   
-  def favorite(listing_id)
-    params_hash = {:id => listing_id}
-    Rails.logger.warn(params_hash)
-    MLS.post('/account/favorites', params_hash) do |code, response|
-      case code
-      when 400
-        @errors = MLS.parse(response.body)[:errors]
-        return false
-      else
-        MLS.handle_response(response)
-        return true
-      end
+  def favorited?(listing)
+    favorites.include?(listing)
+  end
+  
+  def favorite(listing) # TODO: test me, i don't work on failures
+    params_hash = {:id => listing.is_a?(MLS::Listing) ? listing.id : listing }
+    MLS.post('/account/favorites', params_hash) do |response, code|
+      @favorites = nil
+      true
     end
   end
 
-  def unfavorite(listing_id)
-    MLS.delete("/account/favorites/#{listing_id}") do |code, response|
-      case code
-      when 400
-        @errors = MLS.parse(response.body)[:errors]
-        return false
-      else
-        MLS.handle_response(response)
-        return true
-      end
+  def unfavorite(listing_id) # TODO: test me, i don't work on failures
+    listing_id = listing_id.is_a?(MLS::Listing) ? listing_id.id : listing_id
+    MLS.delete("/account/favorites/#{listing_id}") do |response, code|
+      @favorites = nil
+      true
     end
   end
 
-  class << self
+  def to_hash
+    hash = super
+    hash[:password_required] = password_required unless password_required.nil?
+    hash
+  end
     
+  class << self
+
     def current
       response = MLS.get('/account')
       MLS::Account::Parser.parse(response.body)
     end
     
+    # Authenticate and Account via <tt>email</tt> and <tt>password</tt>. Returns
+    # the <tt>Account</tt> object if successfully authenticated. Returns <tt>nil</tt>
+    # if the account could not be found, password was incorrect, or the account
+    # was revoked
+    #
+    # ==== Examples
+    #  #!ruby
+    #  Account.authenticate(:email => 'jon@does.net', :password => 'opensesame') # => #<Account>
+    #    
+    #  Account.authenticate('jon@does.net', 'opensesame') # => #<Account>
+    #
+    #  Account.authenticate('jon@does.net', 'wrong') # => nil
     def authenticate(attrs_or_email, password=nil)
       email = attrs_or_email.is_a?(Hash) ? attrs_or_email[:email] : attrs_or_email
       password = attrs_or_email.is_a?(Hash) ? attrs_or_email[:password] : password
       
       response = MLS.get('/account', {:email => email, :password => password})
       MLS::Account::Parser.parse(response.body)
-    rescue MLS::Unauthorized => response
+    rescue MLS::Exception::Unauthorized => response
       nil
     end
 
     def reset_password!(email)
-      params_hash = {:email => email}
-      Rails.logger.warn(params_hash)
-      MLS.post('/accounts/password/reset', params_hash) do |code, response|
-        case code
-        when 400
-          @errors = MLS.parse(response.body)[:errors]
-          return false
-        else
-          MLS.handle_response(response)
-          return true
-        end
+      MLS.put('/account/reset_password', {:email => email}, 400) do |response, code|
+        MLS::Account::Parser.update(self, response.body)
+        code == 200
       end
     end
 
     def update_password!(params_hash)
-      Rails.logger.warn(params_hash)
-      response = MLS.put('/accounts/password', params_hash)
-      MLS::Account::Parser.parse(response)
-    rescue MLS::BadRequest => response
-      @errors = MLS.parse(response.message)
-      return false
+      MLS.put('/account/update_password', params_hash, 400) do |response, code|
+        MLS::Account::Parser.parse(response.body)
+      end
+    end
+
+    def search(terms)
+      response = MLS.get('/account/search', :query => terms)
+      MLS::Account::Parser.parse_collection(response.body)
     end
 
   end
@@ -147,4 +151,8 @@ end
 
 class MLS::Account::Parser < MLS::Parser
 
+  def favorites=(favorites)
+    @object.favorites = favorites.map {|a| MLS::Listing::Parser.build(a) }
+  end
+
 end

data/lib/mls/models/address.rb

@@ -1,8 +1,8 @@
 class MLS::Address < MLS::Resource
 
-  property :id, Fixnum
-  property :name, String
-  property :slug, String
+  property :id, Fixnum,   :serialize => :if_present
+  property :name, String, :serialize => :false
+  property :slug, String,   :serialize => :if_present
   
   property :latitude, Decimal
   property :longitude, Decimal
@@ -16,6 +16,61 @@ class MLS::Address < MLS::Resource
   property :state, String
   property :country, String
   property :postal_code, String
+  property :min_rate_per_year, Decimal, :serialize => :if_present
+  property :max_rate_per_year, Decimal, :serialize => :if_present
+  property :max_size, Fixnum, :serialize => :if_present
+  property :min_size, Fixnum, :serialize => :if_present
+  property :comments, String
+  property :year_built, Fixnum
+  property :total_size, Fixnum
+  property :floors, Fixnum
+  property :internet_speed, Decimal
+  property :parking_garage, Boolean
+  property :lobby_attendant, Boolean
+  property :gym, Boolean
+  property :leed_certification, String
+  
+  # Counter caches
+  property :listings_count, Fixnum, :serialize => :false
+  property :leased_listings_count, Fixnum, :serialize => :false
+  property :hidden_listings_count, Fixnum, :serialize => :false
+  property :import_listings_count, Fixnum, :serialize => :false
+  property :active_listings_count, Fixnum, :serialize => :false
+
+  attr_accessor :listings, :listing_kinds, :photos
+
+  # should include an optional use address or no_image image
+  def avatar(size='100x200', protocol='http')
+    params = {
+      :size => size,
+      :format => 'png',
+      :sensor => false,
+      :location => [formatted_address],
+      :fov => 120
+    }
+
+    "#{protocol}://maps.googleapis.com/maps/api/streetview?" + params.map{|k,v| k.to_s + '=' + URI.escape(v.to_s) }.join('&')
+  end
+
+  def to_param
+    [state, city, name].map(&:parameterize).join('/')
+  end
+
+  def url
+    if defined? Rails
+      case Rails.env
+      when "production"
+        host = "42floors.com"
+      when "staging"
+        host = "staging.42floors.com"
+      when "development","test"
+        host = "spire.dev"
+      end
+    else
+      host = "42floors.com"
+    end
+    "http://#{host}/#{slug}"
+  end
 
   class << self
     
@@ -25,8 +80,19 @@ class MLS::Address < MLS::Resource
     end
 
     # Bounds is passed as 'n,e,s,w' or [n, e, s, w]
-    def box_cluster(bounds, zoom, filters={})
-      response = MLS.get('/addresses/box_cluster', :bounds => bounds, :zoom => zoom, :filters => filters)
+    def box_cluster(bounds, zoom, where={})
+      MLS.get('/addresses/box_cluster', :bounds => bounds, :zoom => zoom, :where => where)
+    end
+
+    def find(id)
+      response = MLS.get("/addresses/#{id}")
+      MLS::Address::Parser.parse(response.body)
+    end
+
+    # currently supported options are :include, :where, :limit, :offset
+    def all(options={})
+      response = MLS.get('/addresses', options)
+      MLS::Address::Parser.parse_collection(response.body)
     end
     
   end
@@ -35,5 +101,20 @@ end
 
 
 class MLS::Address::Parser < MLS::Parser
-  
+
+  def listings=(listings)
+    @object.listings = listings.map { |data|
+      listing = MLS::Listing::Parser.build(data)
+      listing.address = @object
+      listing
+    }
+  end
+
+  def listing_kinds=(listing_kinds)
+    @object.listing_kinds = listing_kinds
+  end
+
+  def photos=(photos)
+    @object.photos = photos.map {|d| MLS::Photo.new({:digest => d})}
+  end
 end

data/lib/mls/models/area.rb

@@ -0,0 +1,27 @@
+class MLS::Area < MLS::Resource
+
+  property :id,             Fixnum, :serialize => :if_present
+  property :name,           String, :serialize => :if_present
+  property :level,          Fixnum, :serialize => :if_present
+  property :type,           String, :serialize => :if_present
+  property :source,         String, :serialize => :if_present
+  property :geometry,       Hash,   :serialize => false
+  
+  # Counter caches
+  property :listings_count, Fixnum, :serialize => :false
+
+  class << self
+    
+    def find(id)
+      response = MLS.get("/areas/#{id}")
+      MLS::Area::Parser.parse(response.body)
+    end
+    
+  end
+
+end
+
+
+class MLS::Area::Parser < MLS::Parser
+
+end