spark_api 1.0.2 → 1.0.4

data/lib/spark_api/models/idx_link.rb~

@@ -1,47 +0,0 @@
-module FlexmlsApi
-  module Models
-    class IdxLink < Base
-      self.element_name="idxlinks"
-      
-      LINK_TYPES = ["QuickSearch", "SavedSearch", "MyListings", "Roster"]
-
-      #TODO Work all below into common base class
-      def self.find(*arguments)
-        scope = arguments.slice!(0)
-        options = arguments.slice!(0) || {}
-        
-        case scope
-          when :all   then find_every(options)
-          when :first then find_every(options).first
-          when :last  then find_every(options).last
-          when :one   then find_one(options)
-          else             find_single(scope, options)
-        end
-      end
-      
-      def self.first(*arguments)
-        find(:first, *arguments)
-      end
-
-      def self.last(*arguments)
-        find(:last, *arguments)
-      end
-
-      private
-
-      def self.find_every(options)
-        raise NotImplementedError # TODO
-      end
-
-      def self.find_one(options)
-        raise NotImplementedError # TODO
-      end
-
-      def self.find_single(scope, options)
-        resp = FlexmlsApi.client.get("/idxlinks/#{scope}", options)
-        new(resp.first)
-      end
-
-    end
-  end
-end

data/lib/spark_api/models/listing.rb~

@@ -1,197 +0,0 @@
-module FlexmlsApi
-  module Models
-    class Listing < Base 
-      extend Finders
-      attr_accessor :photos, :videos, :virtual_tours, :documents
-      attr_accessor :constraints
-      self.element_name="listings"
-      DATA_MASK = "********"
-      WRITEABLE_FIELDS = ["ListPrice", "ExpirationDate"]
-
-      def initialize(attributes={})
-        @photos = []
-        @videos = []
-        @virtual_tours = []
-        @documents = []
-        @constraints = []
-        
-        if attributes.has_key?('StandardFields')
-          pics, vids, tours, docs = attributes['StandardFields'].values_at('Photos','Videos', 'VirtualTours', 'Documents')
-        end
-        
-        if pics != nil
-          pics.collect { |pic| @photos.push(Photo.new(pic)) } 
-          attributes['StandardFields'].delete('Photos')
-        end
-        
-        if vids != nil
-          vids.collect { |vid| @videos.push(Video.new(vid)) } 
-          attributes['StandardFields'].delete('Videos')
-        end
-
-        if tours != nil
-          tours.collect { |tour| @virtual_tours.push(VirtualTour.new(tour)) }
-          attributes['StandardFields'].delete('VirtualTours')
-        end
-
-        if docs != nil
-          docs.collect { |doc| @documents.push(Document.new(doc)) }
-          attributes['StandardFields'].delete('Documents')
-        end
-        
-        super(attributes)
-      end
-
-      def self.find_by_cart_id(cart_id, options={}) 
-        query = {:_filter => "ListingCart Eq '#{cart_id}'"}
-        find(:all, options.merge(query)) 
-      end
-      
-      def self.my(arguments={})
-        collect(connection.get("/my/listings", arguments))
-      end
-
-      def self.office(arguments={})
-        collect(connection.get("/office/listings", arguments))
-      end
-
-      def self.company(arguments={})
-        collect(connection.get("/company/listings", arguments))
-      end
-      
-      def self.nearby(latitude, longitude, arguments={})
-        nearby_args = {:Lat => latitude, :Lon => longitude}.merge(arguments)
-        collect(connection.get("/listings/nearby", nearby_args))
-      end
-      
-      def tour_of_homes(arguments={})
-        return @tour_of_homes unless @tour_of_homes.nil?
-        @tour_of_homes = TourOfHome.find_by_listing_key(self.Id, arguments)
-      end
-
-      def open_houses(arguments={})
-        return @open_houses unless @open_houses.nil?
-        @open_houses = OpenHouse.find_by_listing_key(self.Id, arguments)
-      end
-      
-      def my_notes
-        Note.build_subclass.tap do |note|
-          note.prefix = "/listings/#{self.ListingKey}"
-          note.element_name = "/my/notes"
-          FlexmlsApi.logger.info("Note.path: #{note.path}")
-        end
-      end
-
-      # 'fore' is required when accessing an agent's shared
-      # notes for a specific contact. If the ApiUser /is/ the
-      # contact, then it can be inferred by the api, so it's
-      # unecessary
-      def shared_notes(fore=nil)
-        Note.build_subclass.tap do |note|
-          note.prefix = "/listings/#{self.ListingKey}"
-          if fore.nil?
-            note.element_name = "/shared/notes"
-          else
-            note.element_name = "/shared/notes/contacts/#{fore}"
-          end
-        end
-      end
-
-      def street_address
-        "#{self.StreetNumber} #{self.StreetDirPrefix} #{self.StreetName} #{self.StreetSuffix} #{self.StreetDirSuffix} #{self.StreetAdditionalInfo}".delete(DATA_MASK).strip().gsub(/\s{2,}/, ' ')
-      end
-
-      def region_address
-        "#{self.City}, #{self.StateOrProvince} #{self.PostalCode}".delete(DATA_MASK).strip().gsub(/^,\s/, '').gsub(/,$/, '')
-      end
-
-      def full_address
-        "#{self.street_address}, #{self.region_address}".strip().gsub(/^,\s/, '').gsub(/,$/, '')
-      end
-      
-      def save(arguments={})
-        self.errors = []
-        begin
-          return save!(arguments)
-        rescue BadResourceRequest => e
-          self.errors << {:code => e.code, :message => e.message}
-          FlexmlsApi.logger.debug("BHDEBUG: #{e.inspect}")
-          if e.code == 1053
-            @constraints = []
-            e.details.each do |detail|
-              detail.each_pair do |k,v|
-                v.each { |constraint| @constraints << Constraint.new(constraint)}
-              end
-            end
-          end
-          FlexmlsApi.logger.error("Failed to save resource #{self}: #{e.message}")
-        rescue NotFound => e
-          FlexmlsApi.logger.error("Failed to save resource #{self}: #{e.message}")
-        end
-        false
-      end
-      def save!(arguments={})
-        writable_changed_keys = changed & WRITEABLE_FIELDS
-        if writable_changed_keys.empty?
-          FlexmlsApi.logger.warn("No supported listing change detected")
-        else
-          results = connection.put "#{self.class.path}/#{self.Id}", build_hash(writable_changed_keys), arguments
-          @contstraints = []
-          results.details.each do |detail|
-            detail.each_pair do |k,v|
-              v.each { |constraint| @constraints << Constraint.new(constraint)}
-            end
-          end
-        end
-        true
-      end
-      
-      def editable?(editable_settings = [])
-        settings = Array(editable_settings)
-        editable = attributes.include?("Permissions") && self.Permissions["Editable"] == true
-        if editable
-          settings.each{ |setting| editable = false unless self.Permissions["EditableSettings"][setting.to_s] == true }
-        end
-        editable
-      end
-      
-      def ExpirationDate
-        attributes["ExpirationDate"]
-      end
-      def ExpirationDate=(value)
-        write_attribute("ExpirationDate", value)
-      end
-      
-      
-      private
-
-      # TODO trim this down so we're only overriding the StandardFields access
-      def method_missing(method_symbol, *arguments)
-        method_name = method_symbol.to_s
-
-        if method_name =~ /(=|\?)$/
-          case $1
-          when "="
-            write_attribute($`,arguments.first)
-            # TODO figure out a nice way to present setters for the standard fields
-          when "?"
-            attributes[$`]
-          end  
-        else 
-          return attributes[method_name] if attributes.include?(method_name)
-          return @attributes['StandardFields'][method_name] if attributes['StandardFields'].include?(method_name)
-          super # GTFO
-        end
-      end
-      
-      def build_hash(keys)
-        hash = {}
-        keys.each do |key|
-          hash[key] = attributes[key]
-        end
-        hash
-      end
-      
-    end
-  end
-end

data/lib/spark_api/models/listing_cart.rb~

@@ -1,72 +0,0 @@
-module FlexmlsApi
-  module Models
-    class ListingCart < Base 
-      extend Finders
-      self.element_name="listingcarts"
-
-      def ListingIds=(listing_ids)
-        attributes["ListingIds"] = Array(listing_ids)
-      end
-      def Name=(name)
-        attributes["Name"] = name
-      end
-      
-      def add_listing(listing)
-        id = listing.respond_to?(:Id) ? listing.Id : listing.to_s
-        results = connection.post("#{self.class.path}/#{self.Id}", {"ListingIds" => [ listing ]})
-        self.ListingCount = results.first["ListingCount"]
-      end
-      
-      def remove_listing(listing)
-        id = listing.respond_to?(:Id) ? listing.Id : listing.to_s
-        results = connection.delete("#{self.class.path}/#{self.Id}/listings/#{id}")
-        self.ListingCount = results.first["ListingCount"]
-      end
-      
-      def self.for(listings,arguments={})
-        keys = Array(listings).map { |l| l.respond_to?(:Id) ? l.Id : l.to_s }
-        collect(connection.get("/#{self.element_name}/for/#{keys.join(",")}", arguments))
-      end
-
-      def self.my(arguments={})
-        collect(connection.get("/my/#{self.element_name}", arguments))
-      end
-
-      def self.portal(arguments={})
-          collect(connection.get("/#{self.element_name}/portal", arguments))
-      end
-      
-      def save(arguments={})
-        begin
-          return save!(arguments)
-        rescue BadResourceRequest => e
-        rescue NotFound => e
-          # log and leave
-          FlexmlsApi.logger.error("Failed to save contact #{self}: #{e.message}")
-        end
-        false
-      end
-      def save!(arguments={})
-        attributes['Id'].nil? ? create!(arguments) : update!(arguments)
-      end
-      
-      def delete(args={})
-        connection.delete("#{self.class.path}/#{self.Id}", args)
-      end
-      
-      private 
-      def create!(arguments={})
-        results = connection.post self.class.path, {"ListingCarts" => [ attributes ]}, arguments
-        result = results.first
-        attributes['ResourceUri'] = result['ResourceUri']
-        attributes['Id'] = parse_id(result['ResourceUri'])
-        true
-      end
-      def update!(arguments={})
-        results = connection.put "#{self.class.path}/#{self.Id}", {"ListingCarts" => [ {"Name" => attributes["Name"], "ListingIds" => attributes["ListingIds"]} ] }, arguments
-        true
-      end
-
-    end
-  end
-end

data/lib/spark_api/models/market_statistics.rb~

@@ -1,33 +0,0 @@
-module FlexmlsApi
-  module Models
-    class MarketStatistics < Base
-      self.element_name="marketstatistics"
-      
-      def self.absorption(parameters={})
-        self.stat('absorption',parameters)
-      end
-      def self.inventory(parameters={})
-        self.stat('inventory',parameters)
-      end
-      def self.price(parameters={})
-        self.stat('price',parameters)
-      end
-      def self.ratio(parameters={})
-        self.stat('ratio',parameters)
-      end
-      def self.dom(parameters={})
-        self.stat('dom',parameters)
-      end
-      def self.volume(parameters={})
-        self.stat('volume',parameters)
-      end
-
-      private 
-      def self.stat(stat_name, parameters={})
-        resp = connection.get("#{path}/#{stat_name}", parameters)
-        new(resp.first)
-      end
-      
-    end
-  end
-end

data/lib/spark_api/models/message.rb~

@@ -1,21 +0,0 @@
-module FlexmlsApi
-  module Models
-    class Message < Base
-      self.element_name="messages"
-      
-      def save(arguments={})
-        begin
-          return save!(arguments)
-        rescue NotFound, BadResourceRequest => e
-          FlexmlsApi.logger.error("Failed to save resource #{self}: #{e.message}")
-        end
-        false
-      end
-      def save!(arguments={})
-        results = connection.post self.class.path, {"Messages" => [ attributes ]}, arguments
-        true
-      end
-      
-    end
-  end
-end

data/lib/spark_api/models/note.rb~

@@ -1,41 +0,0 @@
-module FlexmlsApi
-  module Models
-    class Note < Base
-      extend Subresource 
-      self.element_name = "notes" # not sure this is really of any use...
-      
-      def self.get(options={})
-        ret = super(options)
-        if ret.empty?
-          return nil
-        else
-          return ret.first
-        end
-      end
-
-      def save(arguments={})
-        begin
-          return save!(arguments)
-        rescue BadResourceRequest => e
-        rescue NotFound => e
-          # log and leave
-          FlexmlsApi.logger.error("Failed to save note #{self} (path: #{self.class.path}): #{e.message}")
-        end 
-        false
-      end 
-
-      def save!(args={})
-        args.merge(:Notes => attributes['Note'])
-        results = connection.put(self.class.path, {:Note => attributes['Note']}, args)
-        result = results.first
-        attributes['ResourceUri'] = result['ResourceUri']
-        true
-      end 
-
-      def delete(args={})
-        connection.delete(self.class.path, args)
-      end
-
-    end
-  end
-end

data/lib/spark_api/models/notification.rb~

@@ -1,42 +0,0 @@
-module FlexmlsApi
-  module Models
-    class Notification < Base
-
-      self.element_name = 'notifications'
-
-      def save(arguments={})
-        self.errors = [] # clear the errors hash
-        begin
-          return save!(arguments)
-        rescue BadResourceRequest => e
-          self.errors << {:code => e.code, :message => e.message}
-          FlexmlsApi.logger.error("Failed to save resource #{self}: #{e.message}")
-        rescue NotFound => e
-          FlexmlsApi.logger.error("Failed to save resource #{self}: #{e.message}")
-        end
-        false
-      end
-
-      def save!(arguments={})
-        results = connection.post self.class.path, attributes, arguments
-        result = results.first
-        attributes['ResourceUri'] = result['ResourceUri']
-        true
-      end
-
-      def self.unread()
-        # force pagination so response knows to deal with returned pagination info
-        result = connection.get "#{self.path}/unread", {:_pagination => 'count'}
-        result
-      end
-
-      def self.mark_read(notifications, arguments={})
-        notifications = Array(notifications)
-
-        ids = notifications.map { |n| n.respond_to?('Id') ? n.Id : n }
-        result = connection.put "#{self.path}/#{ids.join(',')}", {'Read' => true}, arguments
-      end
-
-    end
-  end
-end