spark_api 1.0.2 → 1.0.4

data/lib/spark_api/faraday.rb~

@@ -1,64 +0,0 @@
-module FlexmlsApi
-  module FaradayExt
-    #=Flexmls API Faraday middleware
-    # HTTP Response after filter to package api responses and bubble up basic api errors.
-    class FlexmlsMiddleware < Faraday::Response::ParseJson
-      include FlexmlsApi::PaginateHelper      
-      # Handles pretty much all the api response parsing and error handling.  All responses that
-      # indicate a failure will raise a FlexmlsApi::ClientError exception
-      def on_complete(finished_env)
-        body = parse(finished_env[:body])
-        FlexmlsApi.logger.debug("Response Body: #{body.inspect}")
-        unless body.is_a?(Hash) && body.key?("D")
-          raise InvalidResponse, "The server response could not be understood"
-        end
-        response = ApiResponse.new body
-        paging = response.pagination
-        if paging.nil?
-          results = response
-        else
-          if finished_env[:url].query_values["_pagination"] == "count"
-            results = paging['TotalRows']
-          else
-            results = paginate_response(response, paging)
-          end
-        end
-        case finished_env[:status]
-        when 400
-          hash = {:message => response.message, :code => response.code, :status => finished_env[:status]}
-
-          # constraint violation
-          if response.code == 1053
-            details = body['D']['Details']
-            hash[:details] = details
-          end
-          raise BadResourceRequest,hash
-        when 401
-          # Handle the WWW-Authenticate Response Header Field if present. This can be returned by 
-          # OAuth2 implementations and wouldn't hurt to log.
-          auth_header_error = finished_env[:request_headers]["WWW-Authenticate"]
-          FlexmlsApi.logger.warn("Authentication error #{auth_header_error}") unless auth_header_error.nil?
-          raise PermissionDenied, {:message => response.message, :code => response.code, :status => finished_env[:status]}
-        when 404
-          raise NotFound, {:message => response.message, :code => response.code, :status => finished_env[:status]}
-        when 405
-          raise NotAllowed, {:message => response.message, :code => response.code, :status => finished_env[:status]}
-        when 409
-          raise BadResourceRequest, {:message => response.message, :code => response.code, :status => finished_env[:status]}
-        when 500
-          raise ClientError, {:message => response.message, :code => response.code, :status => finished_env[:status]}
-        when 200..299
-          FlexmlsApi.logger.debug("Success!")
-        else 
-          raise ClientError, {:message => response.message, :code => response.code, :status => finished_env[:status]}
-        end
-        finished_env[:body] = results
-      end
-      
-      def initialize(app)
-        super(app)
-      end
-      
-    end
-  end
-end

data/lib/spark_api/models.rb~

@@ -1,33 +0,0 @@
-require 'flexmls_api/models/base'
-require 'flexmls_api/models/constraint'
-require 'flexmls_api/models/finders'
-require 'flexmls_api/models/subresource'
-
-require 'flexmls_api/models/account'
-require 'flexmls_api/models/connect_prefs'
-require 'flexmls_api/models/contact'
-require 'flexmls_api/models/custom_fields'
-require 'flexmls_api/models/document'
-require 'flexmls_api/models/idx_link'
-require 'flexmls_api/models/listing'
-require 'flexmls_api/models/listing_cart'
-require 'flexmls_api/models/market_statistics'
-require 'flexmls_api/models/message'
-require 'flexmls_api/models/note'
-require 'flexmls_api/models/notification'
-require 'flexmls_api/models/open_house'
-require 'flexmls_api/models/photo'
-require 'flexmls_api/models/property_types'
-require 'flexmls_api/models/saved_search'
-require 'flexmls_api/models/shared_listing'
-require 'flexmls_api/models/standard_fields'
-require 'flexmls_api/models/system_info'
-require 'flexmls_api/models/tour_of_home'
-require 'flexmls_api/models/video'
-require 'flexmls_api/models/virtual_tour'
-
-module FlexmlsApi
-  module Models
-
-  end
-end

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

@@ -1,115 +0,0 @@
-module FlexmlsApi
-  module Models
-    class Account < Base
-      extend Finders
-      self.element_name="accounts"
-      
-      SUBELEMENTS = [:emails, :phones, :websites, :addresses, :images]
-      attr_accessor :my_account, *SUBELEMENTS 
-      
-      def initialize(attributes={})
-        @emails = subresource(Email, "Emails", attributes)
-        @phones = subresource(Phone, "Phones", attributes)
-        @websites = subresource(Website, "Websites", attributes)
-        @addresses = subresource(Address, "Addresses", attributes)
-        if attributes["Images"]
-          @images = [] 
-          attributes["Images"].each { |i| @images << Image.new(i) }
-        else
-          @images = nil
-        end
-        @my_account = false
-        super(attributes)
-      end
-
-      def self.my(arguments={})
-        account  = collect(connection.get("/my/account", arguments)).first
-        account.my_account = true
-        account
-      end
-      
-      def my_account?
-        @my_account
-      end
-      
-      def self.by_office(office_id, arguments={})
-        collect(connection.get("#{self.path()}/by/office/#{office_id}", arguments))
-      end
-
-      def primary_img(typ)
-        if @images.is_a?(Array)
-          matches = @images.select {|i| i.Type == typ}
-          matches.sort {|a,b| a.Name <=> b.Name }.first
-        else
-          nil
-        end
-      end
-      
-      def save(arguments={})
-        self.errors = [] # clear the errors hash
-        begin
-          return save!(arguments)
-        rescue NotFound, BadResourceRequest => e
-          self.errors << {:code => e.code, :message => e.message}
-          FlexmlsApi.logger.error("Failed to save resource #{self}: #{e.message}")
-        end
-        false
-      end
-      def save!(arguments={})
-        # The long-term idea is that any setting in the user's account could be updated by including
-        # an attribute and calling PUT /my/account, but for now only the GetEmailUpdates attribute 
-        # is supported
-        
-        save_path = "/accounts/"+self.Id
-        
-        ojbsome = {}
-        if attributes['GetEmailUpdates']
-          save_path = my_account? ? "/my/account" : self.class.path
-          ojbsome["GetEmailUpdates"] = attributes['GetEmailUpdates']
-        end
-        if attributes['PasswordValidation']
-          ojbsome["PasswordValidation"] = attributes['PasswordValidation']
-        end
-        if attributes['Password']
-          ojbsome["Password"] = attributes['Password']
-        end    
-          
-        results = connection.put save_path, ojbsome, arguments
-        true
-      end
-
-
-      private
-
-      def subresource(klass, key, attributes)
-        return nil unless attributes.key?(key)
-        array = attributes[key]
-        result = PrimaryArray.new()
-        array.each do |i|
-          result << klass.new(i)
-        end
-        result
-      end
-
-      class Email < Base
-        include Primary
-      end
-
-      class Phone < Base
-        include Primary
-      end
-
-      class Website < Base
-        include Primary
-      end
-
-      class Address < Base
-        include Primary
-      end
-
-      class Image < Base
-      end
-    end
-  end
-
-end

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

@@ -1,118 +0,0 @@
-module FlexmlsApi
-  module Models
-    # =API Model Base class
-    # Intended to be a lot like working with ActiveResource, this class adds most of the basic 
-    # active model type niceties.
-    class Base
-      extend Paginate
-
-      attr_accessor :attributes, :errors
-      attr_reader :changed
-      
-      # Name of the resource as related to the path name
-      def self.element_name
-        # TODO I'd love to pull in active model at this point to provide default naming
-        @element_name ||= "resource"
-      end
-
-      def self.element_name=(name)
-        @element_name = name
-      end
-      
-      # Resource path prefix, prepended to the url
-      def self.prefix
-        @prefix ||= "/"
-      end
-      def self.prefix=(prefix)
-        @prefix = prefix
-      end
-      def self.path
-        "#{prefix}#{element_name}"
-      end
-      
-      def self.connection
-        FlexmlsApi.client
-      end
-      def connection
-        self.class.connection
-      end
-
-      def initialize(attributes={})
-        @attributes = {}
-        @errors = []
-        @changed = []
-        load(attributes)
-      end
-
-      def load(attributes)
-        attributes.each do |key,val|
-          @attributes[key.to_s] = val
-        end
-      end
-      
-      def self.get(options={})
-        collect(connection.get(path, options))
-      end
-
-      def self.first(options={})
-        get(options).first
-      end
-
-      def self.count(options={})
-        connection.get(path, options.merge({:_pagination=>"count"}))
-      end
-      
-      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 "?" 
-            if attributes.include?($`)
-              attributes[$`] ? true : false
-            else
-              raise NoMethodError
-            end
-          end 
-        else
-          return attributes[method_name] if attributes.include?(method_name)
-          super # GTFO
-        end
-      end
-      
-      def respond_to?(method_symbol, include_private=false)
-        if super
-          return true
-        else
-          method_name = method_symbol.to_s
-
-          if method_name =~ /=$/
-            true
-          elsif method_name =~ /(\?)$/
-            attributes.include?($`)
-          else
-            attributes.include?(method_name)
-          end
-
-        end
-      end
-      
-      def parse_id(uri)
-        uri[/\/.*\/(.+)$/, 1]
-      end
-      
-      protected
-      
-      def write_attribute(attribute,  value)
-        unless attributes[attribute] == value
-          attributes[attribute] = value
-          @changed << attribute unless @changed.include?(attribute)
-        end
-      end
-        
-    end
-  end
-end

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

@@ -1,10 +0,0 @@
-module FlexmlsApi
-  module Models
-    class Connect < Base
-      self.element_name="connect"
-      def self.prefs
-        connection.get("#{path}/prefs")
-      end
-    end
-  end
-end

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

@@ -1,16 +0,0 @@
-module FlexmlsApi
-  module Models
-    class Constraint
-      ATTRIBUTES = ["RuleValue","Value","RuleFieldValue","RuleField","RuleName"]
-      attr_accessor *ATTRIBUTES
-      def initialize(args)
-        ATTRIBUTES.each { |f| send("#{f}=", args[f]) if args.include?(f) || args.include?(f.to_sym) }
-      end
-      
-      def to_s
-        "#{self.RuleName}: Field(#{self.RuleField},#{self.RuleFieldValue}) Value(#{self.RuleValue},#{self.Value})"
-      end
-    end
-  end
-end
-

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

@@ -1,49 +0,0 @@
-module FlexmlsApi
-  module Models
-    class Contact < Base
-      extend Finders
-      self.element_name="contacts"
-      
-      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, {"Contacts" => [ attributes ], "Notify" => notify? }, arguments
-        result = results.first
-        attributes['ResourceUri'] = result['ResourceUri']
-        attributes['Id'] = parse_id(result['ResourceUri'])
-        true
-      end
-      
-      def self.by_tag(tag_name, arguments={})
-        collect(connection.get("#{path}/tags/#{tag_name}", arguments))
-      end
-
-      def self.tags(arguments={})
-        connection.get("#{path}/tags", arguments)
-      end
-
-      def self.my(arguments={})
-        new(connection.get('/my/contact', arguments).first)
-      end
-            
-      # Notify the agent of contact creation via a flexmls message.
-      def notify?
-        @notify == true
-      end
-      def notify=(notify_me=true)
-        @notify = notify_me
-      end
-      
-    end
-  end
-end

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

@@ -1,12 +0,0 @@
-module FlexmlsApi
-  module Models
-    class CustomFields < Base
-      self.element_name="customfields"
-
-
-      def self.find_by_property_type(card_fmt, arguments={})
-        collect(connection.get("#{self.path}/#{card_fmt}", arguments))
-      end
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-module FlexmlsApi
-  module Models
-    class Document < Base
-      extend Subresource
-
-      self.element_name="documents"
-      
-
-    end
-  end
-end

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

@@ -1,45 +0,0 @@
-module FlexmlsApi
-  module Models
-    # =Rails-like finders module
-    # Adds the base set of finder class methods to the models that support them (not all of them do) 
-    module Finders
-
-      def 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 first(*arguments)
-        find(:first, *arguments)
-      end
-      
-      def last(*arguments)
-        find(:last, *arguments)
-      end
-      
-      private
-
-      def find_every(options)
-        collect(connection.get("/#{element_name}", options))
-      end
-
-      def find_one(options)
-        raise NotImplementedError # TODO um... what?
-      end
-
-      def find_single(scope, options)
-        resp = connection.get("/#{element_name}/#{scope}", options)
-        new(resp.first)
-      end
-            
-    end
-  end
-end
-