mls 0.14.0 → 1.0.0

data/lib/mls/models/pdf.rb

@@ -1,15 +0,0 @@
-class MLS::PDF < MLS::Resource
-
-  attribute :id, Fixnum
-  attribute :digest, String
-  attribute :file_url, String
-  attribute :type, String
-
-  def url(style='700x467#', protocol='http')
-    "#{protocol}://#{MLS.image_host}/#{avatar_digest}.jpg?s=#{URI.escape(size)}"
-  end
-end
-
-class MLS::PDF::Parser < MLS::Parser
-
-end

data/lib/mls/models/photo.rb

@@ -1,40 +0,0 @@
-require 'restclient'
-
-class MLS::Photo < MLS::Resource
-
-  attribute :id, Fixnum
-  attribute :digest, String
-  attribute :created_at, DateTime
-  attribute :updated_at, DateTime
-  attribute :file_content_type, String
-  attribute :file_name, String
-  attribute :file_size, Fixnum
-  attribute :url_template, String
-  attribute :caption, String
-  attribute :subject_id, Fixnum
-
-  def url(style=nil, protocol='http')
-    result = "#{protocol}://#{MLS.image_host}/#{digest}.jpg"
-    if style
-      result = result + "?s=#{URI.escape(style)}"
-    end
-    
-    result
-  end
-
-  def self.create(attrs)
-    attrs[:file].rewind
-    url = MLS.url.dup
-    url.user = nil
-    url.path = "/photos"
-    response = RestClient.post(url.to_s, {:photo => attrs}, MLS.headers)
-    attrs[:file].close unless attrs[:file].closed?
-
-    MLS::Photo::Parser.parse(response.body)
-  end
-  
-end
-
-class MLS::Photo::Parser < MLS::Parser
-
-end

data/lib/mls/models/property.rb

@@ -1,114 +0,0 @@
-class MLS::Property < MLS::Resource
-
-  attribute :id, Fixnum,   :serialize => :false
-  attribute :name, String, :serialize => :false
-  attribute :slug, String,   :serialize => :false
-  
-  attribute :latitude, Decimal
-  attribute :longitude, Decimal
-  
-  attribute :description, String
-  attribute :neighborhood, String
-  attribute :constructed, Fixnum
-  attribute :size, Fixnum
-  attribute :floors, Fixnum
-  attribute :leed_certification, String
-  attribute :style, String
-  attribute :height, Decimal
-  attribute :lot_size, Decimal
-
-  attribute :amenities, Hash
-  
-  # Counter caches
-  attribute :listings_count, Fixnum, :serialize => :false
-
-  attribute :avatar_digest, String,   :serialize => false
-
-  attr_accessor :listings, :addresses, :photos, :videos
-
-  # 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
-    }
-
-    if avatar_digest
-      "#{protocol}://#{MLS.image_host}/#{avatar_digest}.jpg?s=#{URI.escape(size)}"
-    else
-      params[:size] = params[:size].match(/\d+x\d+/)[0]
-      "#{protocol}://maps.googleapis.com/maps/api/streetview?" + params.map{|k,v| k.to_s + '=' + URI.escape(v.to_s) }.join('&')
-    end
-  end
-
-  def save
-    MLS.put("/properties/#{id}", {:address => to_hash}, 400) do |response, code|
-      if code == 200 || code == 400
-        MLS::Property::Parser.update(self, response.body)
-        code == 200      
-      else
-        raise MLS::Exception::UnexpectedResponse, code
-      end
-    end
-  end
-
-  def to_hash
-    hash = super
-    hash[:photo_ids] = photos.map(&:id) if photos
-    hash[:videos_attributes] = videos.map(&:to_hash) unless videos.blank?
-    hash
-  end
-
-  def to_param
-    slug
-  end
-
-  class << self
-
-    def find(id)
-      response = MLS.get("/properties/#{id}")
-      MLS::Property::Parser.parse(response.body)
-    end
-
-    # currently supported options are :include, :where, :limit, :offset
-    def all(options={})
-      response = MLS.get('/properties', options)
-      MLS::Property::Parser.parse_collection(response.body)
-    end
-
-    def amenities
-      @amenities ||= Yajl::Parser.new(:symbolize_keys => true).parse(MLS.get('/properties/amenities').body)
-    end
-
-  end
-  
-end
-
-
-class MLS::Property::Parser < MLS::Parser
-
-  def listings=(listings)
-    @object.listings = listings.map { |data|
-      listing = MLS::Listing::Parser.build(data)
-      listing.address = @object
-      listing
-    }
-  end
-
-  def photos=(photos)
-    @object.photos = photos.map {|p| MLS::Photo::Parser.build(p)}
-  end
-
-  def videos=(videos)
-    @object.videos = videos.map do |video|
-      MLS::Video::Parser.build(video)
-    end
-  end
-
-  def addresses=(addresses)
-    @object.addresses = addresses.map {|a| MLS::Property::Parser.build(addresses)}
-  end
-end

data/lib/mls/models/region.rb

@@ -1,56 +0,0 @@
-class MLS::Region < MLS::Resource
-
-  attribute :id,             Fixnum
-  attribute :name,           String
-  attribute :proper_name,    String
-  attribute :common_name,    String
-  attribute :code,           String
-  attribute :type,           String
-  attribute :source,         String
-  attribute :minimum_zoom,   Fixnum
-  attribute :maximum_zoom,   Fixnum
-  attribute :slug,           String
-  attribute :geometry,       Hash
-  attribute :envelope,       Hash
-  attribute :children,       Hash
-
-  # Counter caches
-  attribute :properties_count, Fixnum
-
-  class << self
-
-    def find(id)
-      response = MLS.get("/regions/#{id}")
-      MLS::Region::Parser.parse(response.body)
-    end
-
-    def all(options={})
-      response = MLS.get('/regions', options)
-      MLS::Region::Parser.parse_collection(response.body)
-    end
-
-  end
-
-  def name
-    common_name || proper_name
-  end
-
-  def bounds
-    return nil unless envelope
-    n, e, s, w = nil, nil, nil, nil
-    envelope[:coordinates][0].each do |c|
-      lon, lat = *c
-      n = lat if !n || lat > n
-      e = lon if !e || lon > e
-      s = lat if !s || lat < s
-      w = lon if !w || lon < w
-    end
-    [n, e, s, w]
-  end
-
-end
-
-
-class MLS::Region::Parser < MLS::Parser
-
-end

data/lib/mls/models/tour.rb

@@ -1,54 +0,0 @@
-class MLS::Tour < MLS::Resource
-  attribute :id,                           Fixnum
-  attribute :declined,                     Boolean
-  attribute :client_id,                    Fixnum
-  attribute :agent_id,                     Fixnum
-  attribute :listing_id,                   Fixnum
-  attribute :comments,                     String
-  attribute :agent_comments,               String,    :serialize => :if_present
-  attribute :token,                        String,    :serialize => :false
-  attribute :created_at,                   DateTime,  :serialize => :false
-  attribute :updated_at,                   DateTime,  :serialize => :false
-
-  attr_accessor :client, :listing
-
-  def decline(notes=nil)
-    self.agent_comments = notes
-    MLS.post("/tours/#{token}/decline", {:agent_comments => notes})
-  end
-
-  def declined?
-    declined
-  end
-
-  class << self
-    def get_all_for_account
-      response = MLS.get('/account/tours')
-      MLS::Tour::Parser.parse_collection(response.body)
-    end
-
-    def find_by_token(token)
-      response = MLS.get("/tours/#{token}")
-      MLS::Tour::Parser.parse(response.body)
-    end
-
-    def create(listing_id, account, tour={})
-      params = {:account => account, :tour => tour}
-      response = MLS.post("/listings/#{listing_id}/tour", params)
-      return MLS::Tour::Parser.parse(response.body)
-    end
-  end
-
-end
-
-class MLS::Tour::Parser < MLS::Parser
-  
-  def listing=(listing)
-    @object.listing = MLS::Listing::Parser.build(listing)
-  end
-  
-  def client=(account)
-    @object.client = MLS::Account::Parser.build(account)
-  end
-
-end

data/lib/mls/models/video.rb

@@ -1,18 +0,0 @@
-class MLS::Video < MLS::Resource
-  attribute :id, Fixnum
-  attribute :vts_key, String
-  attribute :video_type, String
-  attribute :subject_type, String, :serialize => false
-  attribute :created_at, DateTime, :serialize => :if_present
-  attribute :updated_at, DateTime, :serialize => :if_present
-
-  attribute :photo_id, Fixnum, :serialize => :if_present
-
-  attr_accessor :photo
-end
-
-class MLS::Video::Parser < MLS::Parser
-  def photo=(photo)
-    @object.photo = MLS::Photo::Parser.build(photo)
-  end
-end

data/lib/mls/parser.rb

@@ -1,74 +0,0 @@
-class MLS::Parser
-
-  attr_reader :object
-
-  def initialize(object=nil, persisted=true)
-    @object = object || self.class.object_class.new({}, persisted)
-  end
-
-  def parse(data)
-    attributes = extract_attributes(data)
-    update_attributes(attributes)
-    object
-  end
-
-  def build(attributes)
-    update_attributes(attributes)
-    object
-  end
-
-  def update_attributes(attributes)
-    attributes.each {|k,v| self.send("#{k}=".to_sym, v) } if attributes
-  end
-
-  def self.parse(data)
-    self.new.parse(data)
-  end
-
-  # TODO: TEST ME
-  def self.build_collection(hash, options={})
-    root = options[:collection_root_element] || collection_root_element
-    collection = []
-    hash[root].each do |attrs|
-      collection << build(attrs)
-    end
-    collection
-  end
-
-  def self.parse_collection(data, options={})
-    build_collection(extract_attributes(data), options)
-  end
-
-  def self.build(attributes)
-    self.new.build(attributes)
-  end
-
-  def self.update(object, data)
-    self.new(object).parse(data)
-  end
-
-  def method_missing(method, *args, &block)
-    object.__send__(method, *args, &block) if object.methods.include?(method)
-  end
-
-  def extract_attributes(data)
-    Yajl::Parser.new(:symbolize_keys => true).parse(data)
-  end
-
-  def self.extract_attributes(data)
-    Yajl::Parser.new(:symbolize_keys => true).parse(data)
-  end
-
-  def self.object_class
-    @object_class ||= ActiveSupport::Inflector.constantize(self.to_s.sub('::Parser',''))
-  end
-
-  def self.root_element
-    object_class.root_element
-  end
-
-  def self.collection_root_element
-    object_class.collection_root_element
-  end
-
-end

data/lib/mls/resource.rb

@@ -1,99 +0,0 @@
-class MLS::Resource
-
-  attr_reader :persisted
-  attr_accessor :errors
-
-  def self.inherited(subclass)
-    subclass.extend(MLS::Model)
-  end
-
-  def initialize(attributes = {}, persisted = false)
-    @persisted = persisted
-    @errors = {}
-    
-    set_default_values
-    update_attributes(attributes)
-  end
-  
-  def new_record?
-    !@persisted
-  end
-  
-  def persisted?
-    @persisted
-  end
-  
-  def save
-    new_record? ? create : update
-  end
-
-  def save!
-    new_record? ? create! : update!
-  end
-
-  def update!
-    update || raise(MLS::Exception::RecordInvalid)
-  end
-
-  def create!
-    create || raise(MLS::Exception::RecordInvalid)
-  end
-
-  def ==(other)
-    self.class == other.class && attributes_for_comparison == other.attributes_for_comparison
-  end
-
-  # Attributes ===================================================================================================
-  
-  def attributes
-    self.class.attributes
-  end
-
-  def attributes_for_comparison
-    compare = {}
-    attributes.reject{ |k, p| attributes_excluded_from_comparison.include?(k) }.each do |k, p|
-      compare[k] = self.send(attributes[k].name.to_sym)
-    end
-    compare
-  end
-
-  def attributes_excluded_from_comparison
-    self.class.attributes_excluded_from_comparison
-  end
-  
-  def set_default_values
-    attributes.each do |name, attribute|
-      self.send("#{name}=".to_sym, attribute.default) if attribute.default
-    end
-  end
-
-  def update_attributes(attrs)
-    attrs.each { |k, v| self.send("#{k}=".to_sym, v) } unless attrs.nil?
-  end
-  
-  # Combo Breaker ================================================================================================
-
-  def to_hash
-    hash = {}
-    
-    attributes.each do |name, attribute|
-      serialize = attribute.options[:serialize]
-      serialize = :always if serialize.nil?
-      case serialize
-      when :always
-        hash[name] = attribute.dump(self.send(name))
-      when :if_present
-        hash[name] = attribute.dump(self.send(name)) if self.send(name)
-      end
-    end
-    
-    hash
-  end
-  
-  #== for rails form stuff
-  
-  def to_key
-    persisted? ? [id] : nil
-  end
-  
-end