simplyrets 0.1 → 1.0.0

data/lib/simplyrets/api/default_api.rb

@@ -0,0 +1,154 @@
+require "uri"
+
+module SimplyRetsClient
+  class Properties_api
+
+    # The SimplyRets Listings API
+    # This is the main endpoint for accessing your properties. View\nall of the available query parameters and make requests below!\nThe API uses Basic Authorization, which most HTTP libraries\nwill handle for you. To use the test test data (which is what\nthis pages uses), you can use the api key `simplyrets` and\nsecret `simplyrets`. Note that the test listings are not live\nMLS listings but the data, query parameters, and response\nbodies will all work the same.\n
+    # @param [Hash] opts the optional parameters
+    # @option opts [String] :q A fuzzy keyword search.\n
+    # @option opts [Integer] :minprice Filter listings by a minimum price.\n
+    # @option opts [Integer] :maxprice Filter listings by a maximum price\n
+    # @option opts [String] :agent Filter the listings returned by an agent ID.  Note, the\nAgent ID is provided by your MLS.\n
+    # @option opts [Integer] :minarea Filter listings by a minimum area size in Sq Ft.\n
+    # @option opts [Integer] :maxarea Filter listings by a maximum area size in Sq Ft.\n
+    # @option opts [Integer] :minbaths Filter listings by a minimum number of bathrooms.\n
+    # @option opts [Integer] :maxbaths Filter listings by a maximum number of bathrooms.\n
+    # @option opts [Integer] :mineds Filter listings by a minimum number of bedrooms.\n
+    # @option opts [Integer] :maxbeds Filter listings by a maximum number of bedrooms.\n
+    # @option opts [Integer] :limit Set the number of listings to return in the response.\nThis defaults to 20 listings, and can be a maximum of 50.\nTo paginate through to the next page of listings, take a\nlook at the `offset` parameter, or the Link in the HTTP\nHeader.\n
+    # @option opts [Integer] :offset Used as a cursor for pagination. Increase the offset parameter\nby the limit to go to the next \"page\" of listings. Also take\na look at the Link HTTP Header for pre-built pagination.\n
+    # @option opts [Array<String>] :brokers Filter the listings returned by brokerage with a Broker ID.\nYou can specific multiple broker parameters. Note, the Broker\nID is provided by your MLS.\n
+    # @option opts [Array<String>] :features Filter the listings returned by specific features.  You\ncan specify multiple.\n
+    # @option opts [Array<String>] :amenities Filter the listings returned by specific amenities.  You\ncan specify multiple amenities.\n
+    # @option opts [Array<String>] :neighborhoods Filter the listings returned by specific neighborhoods and\nsubdivisions. You can specify multiple.\n
+    # @option opts [Array<String>] :points A list of latitude longitude coordinates which contain\nthe property. Our documentation generator does not yet\nsupport using a list of parameters.\n
+    # @option opts [Array<String>] :counties Filter the listings returned by specific counties. You can\nspecify multiple.\n
+    # @option opts [String] :status Request listings by a specific status. This defaults to\nactive and you can only specify one status in a single\nquery.\n
+    # @option opts [String] :type Request listings by a specific property type. This\ndefaults to Residential, and you can only specify one type\nin a single query.\n
+    # @option opts [String] :sort Sort the response by a specific field. Values starting\nwith a minus (-) denote descending order, while the others\nare ascending.\n
+    # @option opts [String] :include Include a limited set of extra fields which are not found\nin the default response body\n- &#39;rooms&#39; include parameter will include\n   any additional rooms as a list.\n- &#39;pool&#39; includes an additional pool description\n- &#39;association&#39; includes additional home owners association data\n
+    # @return [Array<Listing>]
+    def self.properties(opts = {})
+      if SimplyRets.configuration.debug
+        SimplyRets.logger.debug "Calling API: DefaultApi#properties ..."
+      end
+
+      if opts[:'status'] && !['Active', 'Pending', 'Closed'].include?(opts[:'status'])
+        fail 'invalid value for "status", must be one of Active, Pending, Closed'
+      end
+
+      if opts[:'type'] && !['Residential', 'Rential', 'Multifamily', 'Condominium', 'Commercial', 'Land'].include?(opts[:'type'])
+        fail 'invalid value for "type", must be one of Residential, Rential, Multifamily, Condominium, Commercial, Land'
+      end
+
+      if opts[:'sort'] && !['listprice', '-listprice', 'listdate', '-listdate', 'beds', '-beds', 'baths', '-baths'].include?(opts[:'sort'])
+        fail 'invalid value for "sort", must be one of listprice, -listprice, listdate, -listdate, beds, -beds, baths, -baths'
+      end
+
+      if opts[:'include'] && !['pool', 'rooms', 'association'].include?(opts[:'include'])
+        fail 'invalid value for "include", must be one of pool, rooms, association'
+      end
+
+      # resource path
+      path = "/properties".sub('{format}','json')
+
+      # query parameters
+      query_params = {}
+      query_params[:'q'] = opts[:'q'] if opts[:'q']
+      query_params[:'minprice'] = opts[:'minprice'] if opts[:'minprice']
+      query_params[:'maxprice'] = opts[:'maxprice'] if opts[:'maxprice']
+      query_params[:'agent'] = opts[:'agent'] if opts[:'agent']
+      query_params[:'minarea'] = opts[:'minarea'] if opts[:'minarea']
+      query_params[:'maxarea'] = opts[:'maxarea'] if opts[:'maxarea']
+      query_params[:'minbaths'] = opts[:'minbaths'] if opts[:'minbaths']
+      query_params[:'maxbaths'] = opts[:'maxbaths'] if opts[:'maxbaths']
+      query_params[:'mineds'] = opts[:'mineds'] if opts[:'mineds']
+      query_params[:'maxbeds'] = opts[:'maxbeds'] if opts[:'maxbeds']
+      query_params[:'limit'] = opts[:'limit'] if opts[:'limit']
+      query_params[:'offset'] = opts[:'offset'] if opts[:'offset']
+      query_params[:'brokers'] = opts[:'brokers'] if opts[:'brokers']
+      query_params[:'features'] = opts[:'features'] if opts[:'features']
+      query_params[:'amenities'] = opts[:'amenities'] if opts[:'amenities']
+      query_params[:'neighborhoods'] = opts[:'neighborhoods'] if opts[:'neighborhoods']
+      query_params[:'points'] = opts[:'points'] if opts[:'points']
+      query_params[:'counties'] = opts[:'counties'] if opts[:'counties']
+      query_params[:'status'] = opts[:'status'] if opts[:'status']
+      query_params[:'type'] = opts[:'type'] if opts[:'type']
+      query_params[:'sort'] = opts[:'sort'] if opts[:'sort']
+      query_params[:'include'] = opts[:'include'] if opts[:'include']
+
+      # header parameters
+      header_params = {}
+
+      # HTTP header 'Accept' (if needed)
+      _header_accept = []
+      _header_accept_result = SimplyRets::Request.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
+
+      # HTTP header 'Content-Type'
+      _header_content_type = []
+      header_params['Content-Type'] = SimplyRets::Request.select_header_content_type(_header_content_type)
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+
+
+      auth_names = ['basicAuth']
+      response = SimplyRets::Request.new(:GET, path, {:params => query_params, :headers => header_params, :form_params => form_params, :body => post_body, :auth_names => auth_names}).make
+      result = response.deserialize('Array<Listing>')
+      if SimplyRets.configuration.debug
+        SimplyRets.logger.debug "API called: DefaultApi#properties. Result: #{result.inspect}"
+      end
+      result
+    end
+
+    # Single Listing Endpoint
+    # Use this endpoint for accessing a single listing.\n
+    # @param listing_id A listings listingId (unique indentifier).
+    # @param [Hash] opts the optional parameters
+    # @return [Listing]
+    def self.property(listing_id, opts = {})
+      if SimplyRets.configuration.debug
+        SimplyRets.logger.debug "Calling API: DefaultApi#property ..."
+      end
+
+      # verify the required parameter 'listing_id' is set
+      fail "Missing the required parameter 'listing_id' when calling property" if listing_id.nil?
+
+      # resource path
+      path = "/properties/{listingId}".sub('{format}','json').sub('{' + 'listingId' + '}', listing_id.to_s)
+
+      # query parameters
+      query_params = {}
+
+      # header parameters
+      header_params = {}
+
+      # HTTP header 'Accept' (if needed)
+      _header_accept = []
+      _header_accept_result = SimplyRets::Request.select_header_accept(_header_accept) and header_params['Accept'] = _header_accept_result
+
+      # HTTP header 'Content-Type'
+      _header_content_type = []
+      header_params['Content-Type'] = SimplyRets::Request.select_header_content_type(_header_content_type)
+
+      # form parameters
+      form_params = {}
+
+      # http body (model)
+      post_body = nil
+
+
+      auth_names = ['basicAuth']
+      response = SimplyRets::Request.new(:GET, path, {:params => query_params, :headers => header_params, :form_params => form_params, :body => post_body, :auth_names => auth_names}).make
+      result = response.deserialize('Listing')
+      if SimplyRets.configuration.debug
+        SimplyRets.logger.debug "API called: DefaultApi#property. Result: #{result.inspect}"
+      end
+      result
+    end
+  end
+end

data/lib/simplyrets/listing.rb~

@@ -0,0 +1,199 @@
+module SwaggerClient
+  # 
+  class Listing < BaseObject
+    attr_accessor :property, :mls_id, :showing_instructions, :office, :disclaimer, :address, :list_date, :agent, :modified, :school, :sales, :photos, :list_price, :listing_id, :mls, :geo, :tax, :remarks, :private_remarks, :lease_term, :lease_type
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+        
+        # Specific property data associated with listing.
+        :'property' => :'property',
+        
+        # A unique identifier for this listing specific to the SimplyRETS API.\n
+        :'mls_id' => :'mlsId',
+        
+        # Public instructions for showing the property.
+        :'showing_instructions' => :'showingInstructions',
+        
+        # Listing office or brokerage.
+        :'office' => :'office',
+        
+        # Data accuracy disclaimer. The value in the disclaimer may\nchange depending on your MLS vendors rules.\n
+        :'disclaimer' => :'disclaimer',
+        
+        # Comprehensive property address information
+        :'address' => :'address',
+        
+        # Date and time the listing became Active
+        :'list_date' => :'listDate',
+        
+        # Comprehensive listing agent information
+        :'agent' => :'agent',
+        
+        # Date and time of the last modification
+        :'modified' => :'modified',
+        
+        # Comprehensive school zone data
+        :'school' => :'school',
+        
+        # Sales data
+        :'sales' => :'sales',
+        
+        # Photos of the property. Images are served over https and are\nsuitable for production use on secure websites\n
+        :'photos' => :'photos',
+        
+        # Price of the listing
+        :'list_price' => :'listPrice',
+        
+        # Data Dictionary v1.3 ListingId. The well known identifier\nfor the listing. The value may be identical to\nmlsId. However, listingId is intended to be the value used\nby a human to retrieve the information about a specific\nlisting.\n
+        :'listing_id' => :'listingId',
+        
+        # MLS vendor information and data
+        :'mls' => :'mls',
+        
+        # Geographic data for the listing
+        :'geo' => :'geo',
+        
+        # Associate tax data
+        :'tax' => :'tax',
+        
+        # Description or remarks
+        :'remarks' => :'remarks',
+        
+        # Agent only remarks
+        :'private_remarks' => :'privateRemarks',
+        
+        # 
+        :'lease_term' => :'leaseTerm',
+        
+        # 
+        :'lease_type' => :'leaseType'
+        
+      }
+    end
+
+    # attribute type
+    def self.swagger_types
+      {
+        :'property' => :'Property',
+        :'mls_id' => :'Integer',
+        :'showing_instructions' => :'String',
+        :'office' => :'Office',
+        :'disclaimer' => :'String',
+        :'address' => :'StreetAddress',
+        :'list_date' => :'DateTime',
+        :'agent' => :'Agent',
+        :'modified' => :'DateTime',
+        :'school' => :'School',
+        :'sales' => :'Sales',
+        :'photos' => :'Array<String>',
+        :'list_price' => :'Float',
+        :'listing_id' => :'String',
+        :'mls' => :'MlsInformation',
+        :'geo' => :'GeographicData',
+        :'tax' => :'Tax',
+        :'remarks' => :'String',
+        :'private_remarks' => :'String',
+        :'lease_term' => :'String',
+        :'lease_type' => :'String'
+        
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+      
+      if attributes[:'property']
+        self.property = attributes[:'property']
+      end
+      
+      if attributes[:'mlsId']
+        self.mls_id = attributes[:'mlsId']
+      end
+      
+      if attributes[:'showingInstructions']
+        self.showing_instructions = attributes[:'showingInstructions']
+      end
+      
+      if attributes[:'office']
+        self.office = attributes[:'office']
+      end
+      
+      if attributes[:'disclaimer']
+        self.disclaimer = attributes[:'disclaimer']
+      end
+      
+      if attributes[:'address']
+        self.address = attributes[:'address']
+      end
+      
+      if attributes[:'listDate']
+        self.list_date = attributes[:'listDate']
+      end
+      
+      if attributes[:'agent']
+        self.agent = attributes[:'agent']
+      end
+      
+      if attributes[:'modified']
+        self.modified = attributes[:'modified']
+      end
+      
+      if attributes[:'school']
+        self.school = attributes[:'school']
+      end
+      
+      if attributes[:'sales']
+        self.sales = attributes[:'sales']
+      end
+      
+      if attributes[:'photos']
+        if (value = attributes[:'photos']).is_a?(Array)
+          self.photos = value
+        end
+      end
+      
+      if attributes[:'listPrice']
+        self.list_price = attributes[:'listPrice']
+      end
+      
+      if attributes[:'listingId']
+        self.listing_id = attributes[:'listingId']
+      end
+      
+      if attributes[:'mls']
+        self.mls = attributes[:'mls']
+      end
+      
+      if attributes[:'geo']
+        self.geo = attributes[:'geo']
+      end
+      
+      if attributes[:'tax']
+        self.tax = attributes[:'tax']
+      end
+      
+      if attributes[:'remarks']
+        self.remarks = attributes[:'remarks']
+      end
+      
+      if attributes[:'privateRemarks']
+        self.private_remarks = attributes[:'privateRemarks']
+      end
+      
+      if attributes[:'leaseTerm']
+        self.lease_term = attributes[:'leaseTerm']
+      end
+      
+      if attributes[:'leaseType']
+        self.lease_type = attributes[:'leaseType']
+      end
+      
+    end
+
+  end
+end

data/lib/simplyrets/models/agent.rb

@@ -0,0 +1,61 @@
+module SimplyRetsClient
+  #
+  class Agent < BaseObject
+    attr_accessor :last_name, :contact, :first_name, :id
+    # attribute mapping from ruby-style variable name to JSON key
+    def self.attribute_map
+      {
+
+        # Agent last name
+        :'last_name' => :'lastName',
+
+        # Agent contact info. This information is only present when\nyour RETS feed specifies the agent wishes to show their\ncontact information publicly.\n
+        :'contact' => :'contact',
+
+        # Agent first name
+        :'first_name' => :'firstName',
+
+        # Well known Agent MLS number or id.
+        :'id' => :'id'
+
+      }
+    end
+
+    # attribute type
+    def self.simplyrets_types
+      {
+        :'last_name' => :'String',
+        :'contact' => :'ContactInformation',
+        :'first_name' => :'String',
+        :'id' => :'String'
+
+      }
+    end
+
+    def initialize(attributes = {})
+      return if !attributes.is_a?(Hash) || attributes.empty?
+
+      # convert string to symbol for hash key
+      attributes = attributes.inject({}){|memo,(k,v)| memo[k.to_sym] = v; memo}
+
+
+      if attributes[:'lastName']
+        self.last_name = attributes[:'lastName']
+      end
+
+      if attributes[:'contact']
+        self.contact = attributes[:'contact']
+      end
+
+      if attributes[:'firstName']
+        self.first_name = attributes[:'firstName']
+      end
+
+      if attributes[:'id']
+        self.id = attributes[:'id']
+      end
+
+    end
+
+  end
+end

data/lib/simplyrets/models/base_object.rb

@@ -0,0 +1,87 @@
+require 'date'
+
+module SimplyRetsClient
+  # base class containing fundamental method such as to_hash, build_from_hash and more
+  class BaseObject
+
+    # build the object from hash
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      self.class.simplyrets_types.each_pair do |key, type|
+        if type =~ /^Array<(.*)>/i
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map{ |v| _deserialize($1, v) } )
+          else
+            #TODO show warning in debug mode
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        else
+          # data not found in attributes(hash), not an issue as the data can be optional
+        end
+      end
+
+      self
+    end
+
+    def _deserialize(type, value)
+      case type.to_sym
+      when :DateTime
+        DateTime.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :BOOLEAN
+        if value =~ /^(true|t|yes|y|1)$/i
+          true
+        else
+          false
+        end
+      else # model
+        _model = SimplyRetsClient.const_get(type).new
+        _model.build_from_hash(value)
+      end
+    end
+
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_body (backward compatibility))
+    def to_body
+      to_hash
+    end
+
+    # return the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |key, value|
+        if self.send(key).is_a?(Array)
+          next if self.send(key).empty?
+          hash[value] = self.send(key).select{|v| !v.nil?}.map{ |v| _to_hash v} unless self.send(key).nil?
+        else
+          unless (_tmp_value = _to_hash self.send(key)).nil?
+            hash[value] = _tmp_value
+          end
+        end
+      end
+      hash
+    end
+
+    # Method to output non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    def _to_hash(value)
+      if value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+end