caboose-rets 0.1.18 → 0.1.19

data/app/models/caboose_rets/office.rb

@@ -2,8 +2,8 @@
 class CabooseRets::Office < ActiveRecord::Base
   self.table_name = "rets_offices"
   
-  has_one :meta, :class_name => 'OfficeMeta', :primary_key => 'lo_code', :foreign_key => 'lo_code'  
-  attr_accessible :id, :name, :lo_code
+  has_one :meta, :primary_key => 'matrix_unique_id', :foreign_key => 'matrix_unique_id'  
+  attr_accessible :id, :name, :lo_mls_id, :matrix_unique_id
   
   def image
     return nil if self.meta.nil?
@@ -11,24 +11,38 @@ class CabooseRets::Office < ActiveRecord::Base
   end
   
   def parse(data)
-    self.lo_date_created 	    = data['LO_DATE_CREATED']
-    self.lo_date_modified 	  = data['LO_DATE_MODIFIED']
-    self.lo_email 		        = data['LO_EMAIL']
-    self.lo_fax_phone 	      = data['LO_FAX_PHONE']
-    self.lo_idx_yn 		        = data['LO_IDX_YN']
-    self.lo_code 	            = data['LO_LO_CODE']
-    self.lo_mailaddr1 	      = data['LO_MAILADDR1']
-    self.lo_mailaddr2 	      = data['LO_MAILADDR2']
-    self.lo_mailcity 	        = data['LO_MAILCITY']
-    self.lo_mailstate 	      = data['LO_MAILSTATE']
-    self.lo_mailzip 	        = data['LO_MAILZIP']
-    self.lo_main_lo_code 	    = data['LO_MAIN_LO_CODE']
-    self.lo_name 	            = data['LO_NAME']
-    self.lo_other_phone 	    = data['LO_OTHER_PHONE']
-    self.lo_page 		          = data['LO_PAGE']
-    self.lo_phone 	          = data['LO_PHONE']
-    self.lo_status 		        = data['LO_STATUS']
-    self.photo_count 		      = data['PHOTO_COUNT']
-    self.photo_date_modified  = data['PHOTO_DATE_MODIFIED']
+        self.lo_addr1                     = data['Addr1']
+        self.lo_addr2                     = data['Addr2']
+        self.lo_city                      = data['City']
+        self.lo_email                     = data['Email']
+        self.lo_fax_phone                 = data['FaxPhone']
+        self.lo_mail_addr                 = data['MailAddr']
+        self.lo_mail_care_of              = data['MailCareOf']
+        self.lo_mail_city                 = data['MailCity']
+        self.lo_mail_postal_code          = data['MailPostalCode']
+        self.lo_mail_postal_code_plus4    = data['MailPostalCodePlus4']
+        self.lo_mail_state_or_province    = data['MailStatOrProvince']
+        self.matrix_unique_id             = data['Matrix_Unique_ID']
+        self.lo_matrix_modified_dt        = data['MatrixModifiedDT']
+        self.lo_mls                       = data['MLS']
+        self.lo_mls_id                    = data['MLSID']
+        self.lo_office_contact_mui        = data['OfficeContact_MUI']
+        self.lo_office_contact_mls_id     = data['OfficeContactMLSID']        
+        self.lo_office_long_name          = data['OfficeLongName']
+        self.lo_office_name               = data['OfficeName']
+        self.lo_phone                     = data['Phone']
+        self.lo_photo_count               = data['PhotoCount']
+        self.photo_modification_timestamp = data['PhotoModificationTimestamp']        
+        self.state                        = data['State']
+        self.street_address               = data['StreetAddress']
+        self.street_city                  = data['StreetCity']
+        self.street_postal_code           = data['StreetPostalCode']
+        self.street_postal_code_plus4     = data['StreetPostalCodePlus4']
+        self.street_state_or_province     = data['StreeStateOrProvince']
+        self.web_facebook                 = data['WebFacebook']
+        self.web_linked_in                = data['WebLinkedIn']
+        self.web_page_address             = data['WebPageAddress']
+        self.web_twitter                  = data['WebTwitter']
+        self.zip                          = data['ZIP'] 
   end
 end

data/app/models/caboose_rets/open_house.rb

@@ -2,10 +2,10 @@
 class CabooseRets::OpenHouse < ActiveRecord::Base
   self.table_name = "rets_open_houses"
   
-  attr_accessible :id
+  attr_accessible :id, :matrix_unique_id
   
   def property
-    models = [CabooseRets::ResidentialProperty, CabooseRets::CommercialProperty, CabooseRets::LandProperty, CabooseRets::MultiFamilyProperty]
+    models = [CabooseRets::Property]
     models.each do |model|
       id = self.mls_acct.to_i
       return model.find(id) if model.exists?(id)
@@ -14,22 +14,22 @@ class CabooseRets::OpenHouse < ActiveRecord::Base
   end
   
   def agent
-    return CabooseRets::Agent.where(:la_code => self.la_code).first if CabooseRets::Agent.exists?(:la_code => self.la_code)
+    return CabooseRets::Agent.where(:mls_id => self.mls_id).first if CabooseRets::Agent.exists?(:mls_id => self.mls_id)
     return nil
   end
   
   def parse(data)
-    self.id 		          = data['ID']
-    self.comments 		    = data['COMMENTS']
-    self.date_created 		= data['DATE_CREATED']
-    self.date_modified 		= data['DATE_MODIFIED']
-    self.end_time 		    = data['END_TIME']    
-    self.la_code 		      = data['LA_CODE']
-    self.mls_acct 		    = data['MLS_ACCT']
-    self.open_house_date 	= data['OPEN_HOUSE_DATE']
-    self.open_house_type 	= data['OPEN_HOUSE_TYPE']
-    self.perpetual_yn 		= data['PERPETUAL_YN']
-    self.prop_type 		    = data['PROP_TYPE']
-    self.start_time 		  = data['START_TIME']
+        self.active_yn          = data['ActiveYN']
+        self.description        = data['Description']
+        self.end_time           = data['EndTime']
+        self.entry_order        = data['EntryOrder']
+        self.listing_mui        = data['ListingMUI']
+        self.matrix_unique_id   = data['matrix_unique_id']
+        self.matrix_modified_dt = data['MatrixModifiedDT']
+        self.open_house_date    = data['OpenHouseDate']
+        self.open_house_type    = data['OpenHouseType']
+        self.provider_key       = data['ProviderKey']
+        self.refreshments       = data['Refrehments']
+        self.start_time         = data['StartTime'] 
   end
 end

data/app/models/caboose_rets/property.rb

@@ -0,0 +1,203 @@
+class CabooseRets::Property <ActiveRecord::Base
+    self.table_name = "rets_properties"
+    attr_accessible :id, :matrix_unique_id
+
+    def url()     return "/property/#{self.id}" end
+    def images()  return CabooseRets::Media.where(:media_mui => self.matrix_unique_id, :media_type => 'Photo').reorder(:media_order).all end
+    def files()   return CabooseRets::Media.where(:media_mui => self.matrix_unique_id, :media_type => 'File' ).reorder(:media_order).all end
+    def virtual_tour
+        return nil if !CabooseRets::Media.where(:mls => self.mls.to_s).where(:media_type => 'Virtual Tour').exists?
+        media = CabooseRets::Media.where(:mls => self.mls.to_s, :media_type => 'Virtual Tour').first
+        return media.url
+    end
+    def self.geolocatable() all(conditions: "latitude IS NOT NULL AND longitude IS NOT NULL") end
+
+    def refresh_from_mls
+        CabooseRets::RetsImporter.import_property(self.matrix_unique_id)
+    end
+
+    def parse(data)
+        self.access                           = data['Access']
+        self.acreage                          = data['Acreage']
+        self.acreage_source                   = data['AcreageSource']
+        self.active_open_house_count          = data['ActiveOpenHouseCount']
+        self.adjoining_land_use               = data['AdjoiningLandUse']
+        self.age                              = data['Age']
+        self.annual_taxes                     = data['AnnualTaxes']
+        self.appliances                       = data['Appliances']
+        self.area                             = data['Area']
+        self.attic                            = data['Attic']
+        self.available_date                   = data['AvailableDate']
+        self.basement                         = data['Basement']
+        self.basement_yn                      = data['BasementYN']
+        self.baths_full                       = data['BathsFull']
+        self.baths_half                       = data['BathsHalf']
+        self.baths_total                      = data['BathsTotal']
+        self.beds_total                       = data['BedsTotal']
+        self.book_number                      = data['BookNumber']
+        self.book_page                        = data['BookPage']
+        self.book_type                        = data['BookType']
+        self.building_type                    = data['BuildingType']
+        self.business_included_yn             = data['BusinessIncludedYN']
+        self.buyer_name                       = data['BuyerName']
+        self.city                             = data['City']
+        self.city_community                   = data['CityCommunity']
+        self.closing                          = data['Closing']
+        self.co_list_agent_mui                = data['CoListAgent_MUI']
+        self.co_list_agent_direct_work_phone  = data['CoListAgentDirectWorkPhone']
+        self.co_list_agent_email              = data['CoListAgentEmail']
+        self.co_list_agent_full_name          = data['CoListAgentFullName']
+        self.co_list_agent_mls_id             = data['CoListAgentMLSID']
+        self.co_list_office_mui               = data['CoListOffice_MUI']
+        self.co_list_office_mls_id            = data['CoListOfficeMLSID']
+        self.co_list_office_name              = data['CoListOfficeName']
+        self.co_list_office_phone             = data['CoListOfficePhone']
+        self.completion_date                  = data['CompletionDate']
+        self.comp_tenant_rep                  = data['CompTenantRep']
+        self.construction                     = data['Construction']
+        self.construction_status              = data['ConstructionStatus']
+        self.cooling                          = data['Cooling']
+        self.county_or_parish                 = data['CountyOrParish']
+        self.deposit                          = data['Deposit']
+        self.dining_room                      = data['DiningRoom']
+        self.directions                       = data['Directions']
+        self.display_address_on_internet_yn   = data['DisplayAddressOnInternetYN']
+        self.dom                              = data['DOM']
+        self.driveway                         = data['Driveway']
+        self.elementary_school                = data['ElementarySchool']
+        self.exists_struct                    = data['ExistStruct']
+        self.expenses_association             = data['ExpensesAssociation']
+        self.expenses_insurance               = data['ExpensesInsurance']
+        self.expenses_maintenance             = data['ExpensesMaintenance']
+        self.expenses_management              = data['ExpensesManagement']
+        self.expenses_other                   = data['ExpensesOther']
+        self.expenses_tax                     = data['ExpensesTax']
+        self.expenses_utility                 = data['ExpensesUtility']
+        self.exterior_features                = data['ExteriorFeatures']
+        self.fireplace                        = data['Fireplace']
+        self.flood_plain                      = data['FloodPlain']
+        self.flooring                         = data['Flooring']
+        self.foreclosure_sale_date            = data['ForeclosureSaleDate']
+        self.foreclosure_yn                   = data['ForeclosureYN']
+        self.fsboyn                           = data['FSBOYN']
+        self.garage                           = data['Garage']
+        self.heating                          = data['Heating']
+        self.high_school                      = data['HighSchool']
+        self.hoa_amenities                    = data['HOAAmenities']
+        self.hoa_fee                          = data['HOAFee']
+        self.hoa_included_in_rent_yn          = data['HOAIncludedInRentYN']
+        self.hoa_term                         = data['HOATerm']
+        self.hoa_term_mandatory_yn            = data['HOATermMandatoryYN']
+        self.homestead_yn                     = data['HomesteadYN']
+        self.idx_opt_in_yn                    = data['IDXOptInYN']
+        self.income_other                     = data['IncomeOther']
+        self.income_rental                    = data['IncomeRental']
+        self.interior_features                = data['InteriorFeatures']
+        self.land_features_extras             = data['LandFeaturesExtras']
+        self.landscaping                      = data['Landscaping']
+        self.laundry                          = data['Laundry']
+        self.legal_description                = data['LegalDescription']
+        self.legal_lot                        = data['LegalLot']
+        self.legal_section                    = data['LegalSection']
+        self.levels                           = data['Levels']
+        self.list_agent_mui                   = data['ListAgent_MUI']
+        self.list_agent_direct_work_phone     = data['ListAgentDirectWorkPhone']
+        self.list_agent_email                 = data['ListAgentEmail']
+        self.list_agent_full_name             = data['ListAgentFullName']
+        self.list_agent_mls_id                = data['ListAgentMLSID']
+        self.listing_contract_date            = data['ListingContractDate']
+        self.list_office_mui                  = data['ListOffice_MUI']
+        self.list_office_mls_id               = data['ListOfficeMLSID']
+        self.list_office_name                 = data['ListOfficeName']
+        self.list_office_phone                = data['ListOfficePhone']
+        self.list_price                       = data['ListPrice']
+        self.lot_description                  = data['LotDescription']
+        self.lot_dimensions                   = data['LotDimensions']
+        self.lot_dim_source                   = data['LotDimSource']
+        self.management                       = data['Management']
+        self.master_bed_level                 = data['MasterBedLevel']
+        self.matrix_unique_id                 = data['Matrix_Unique_ID']
+        self.matrix_modified_dt               = data['MatrixModifiedDT']
+        self.max_sqft                         = data['MaxSqft']
+        self.middle_school                    = data['MiddleSchool']
+        self.mineral_rights                   = data['MineralRights']
+        self.min_sqft                         = data['MinSqft']
+        self.misc_indoor_featuresa            = data['MiscIndoorFeatures']
+        self.mls                              = data['MLS']
+        self.mls_number                       = data['MLSNumber']
+        self.municipality                     = data['Municipality']
+        self.net_op_inc                       = data['NetOpInc']
+        self.open_house_count                 = data['OpenHouseCount']
+        self.open_house_public_count          = data['OpenHousePublicCount']
+        self.open_house_public_upcoming       = data['OpenHousePublicUpcoming']
+        self.open_house_upcoming              = data['OpenHouseUpcoming']
+        self.parcel_number                    = data['ParcelNumber']
+        self.pending_date                     = data['PendingDate']
+        self.pets_allowed_yn                  = data['PetsAllowedYN']
+        self.photo_count                      = data['PhotoCount']
+        self.photo_modification_timestamp     = data['PhotoModificationTimestamp']
+        self.pool                             = data['Pool']
+        self.porch_patio                      = data['PorchPatio']
+        self.possession                       = data['Possession']
+        self.possible_uses                    = data['PossibleUses']
+        self.postal_code                      = data['PostalCode']
+        self.postal_code_plus4                = data['PostalCodePlus4']
+        self.price_per_acre                   = data['PricePerAcre']
+        self.price_sqft                       = data['PriceSqft']
+        self.property_name                    = data['PropertyName']
+        self.property_subtype                 = data['PropertySubType']
+        self.property_type                    = data['PropertyType']
+        self.property_use                     = data['PropertyUse']
+        self.prop_mgmt_comp                   = data['PropMgmtComp']
+        self.public_remarks                   = data['PublicRemarks']
+        self.refrigerator_included_yn         = data['RefrigeratorIncludedYN']
+        self.rental_rate_type                 = data['RentalRateType']
+        self.rent_incl                        = data['RentIncl']
+        self.res_style                        = data['ResStyle']
+        self.restrictions                     = data['Restrictions']
+        self.road_frontage                    = data['RoadFrontage']
+        self.roof                             = data['Roof']
+        self.roofage                          = data['Roofage']
+        self.room_count                       = data['RoomCount']
+        self.service_type                     = data['ServiceType']
+        self.sewer                            = data['Sewer']
+        self.sold_terms                       = data['SoldTerms']
+        self.sprinkler                        = data['Sprinkler']
+        self.sqft_source                      = data['SqftSource']
+        self.sqft_total                       = data['SqFtTotal']
+        self.state_or_province                = data['StateOrProvince']
+        self.status                           = data['Status']
+        self.status_contractual_search_date   = data['StatusContractualSearchDate']
+        self.street_dir_prefix                = data['StreetDirPrefix']
+        self.street_dir_suffix                = data['StreetDirSuffix']
+        self.street_name                      = data['StreetName']
+        self.street_number                    = data['StreetNumber']
+        self.street_number_numeric            = data['StreetNumberNumeric']
+        self.street_suffix                    = data['StreetSuffix']
+        self.street_view_param                = data['StreetViewParam']
+        self.style                            = data['Style']
+        self.subdivision                      = data['Subdivision']
+        self.topography                       = data['Topography']
+        self.total_num_units                  = data['TotalNumOfUnits']
+        self.total_num_units_occupied         = data['TotalNumOfUnitsOccupied']
+        self.transaction_type                 = data['TransactionType']
+        self.unit_count                       = data['UnitCount']
+        self.unit_number                      = data['UnitNumber']
+        self.utilities                        = data['Utilities']
+        self.virtual_tour1                    = data['VirtualTour1']
+        self.vow_allowed_avmyn                = data['VOWAllowAVMYN']
+        self.vow_allowed_third_party_comm_yn  = data['VOWAllowThirdPartyCommYN']
+        self.washer_dryer_included            = data['WasherDryerIncludedYN']
+        self.water                            = data['Water']
+        self.waterfronts                      = data['Waterfronts']
+        self.waterfront_yn                    = data['WaterfrontYN']
+        self.water_heater                     = data['WaterHeater']
+        self.windows                          = data['Windows']
+        self.window_treatments                = data['WindowTreatments']
+        self.year_built                       = data['YearBuilt']
+        self.yr_blt_source                    = data['YrBltSource']
+        self.zoning                           = data['Zoning']
+        self.zoning_northport                 = data['ZoningNorthPort']
+        self.zoning_tusc                      = data['ZoningTusc']
+    end
+end

data/app/models/caboose_rets/rets_importer.rb

@@ -15,7 +15,7 @@ require 'json'
 
 class CabooseRets::RetsImporter # < ActiveRecord::Base
 
-  @@rets_client = nil
+  @@rets_client = nil   
   @@config = nil
 
   def self.config
@@ -31,7 +31,7 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
       'log_file'            => nil,
       'media_base_url'      => nil
     }
-    config = YAML::load(File.open("#{Rails.root}/config/rets_importer.yml"))
+    config = YAML::load(File.open("#{Rails.root}/config/rets_importer.yml"))    
     config = config[Rails.env]
     config.each { |key,val| @@config[key] = val }
   end
@@ -51,34 +51,31 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
 
   def self.meta(class_type)
     case class_type
-      when 'RES' then Caboose::StdClass.new({ :search_type => 'Property'  , :remote_key_field => 'MLS_ACCT'   , :local_key_field => 'mls_acct' , :local_table => 'rets_residential'  , :date_modified_field => 'DATE_MODIFIED'    })
-      when 'COM' then Caboose::StdClass.new({ :search_type => 'Property'  , :remote_key_field => 'MLS_ACCT'   , :local_key_field => 'mls_acct' , :local_table => 'rets_commercial'   , :date_modified_field => 'DATE_MODIFIED'    })
-      when 'LND' then Caboose::StdClass.new({ :search_type => 'Property'  , :remote_key_field => 'MLS_ACCT'   , :local_key_field => 'mls_acct' , :local_table => 'rets_land'         , :date_modified_field => 'DATE_MODIFIED'    })
-      when 'MUL' then Caboose::StdClass.new({ :search_type => 'Property'  , :remote_key_field => 'MLS_ACCT'   , :local_key_field => 'mls_acct' , :local_table => 'rets_multi_family' , :date_modified_field => 'DATE_MODIFIED'    })
-      when 'OFF' then Caboose::StdClass.new({ :search_type => 'Office'    , :remote_key_field => 'LO_LO_CODE' , :local_key_field => 'lo_code'  , :local_table => 'rets_offices'      , :date_modified_field => 'LO_DATE_MODIFIED' })
-      when 'AGT' then Caboose::StdClass.new({ :search_type => 'Agent'     , :remote_key_field => 'LA_LA_CODE' , :local_key_field => 'la_code'  , :local_table => 'rets_agents'       , :date_modified_field => 'LA_DATE_MODIFIED' })
-      when 'OPH' then Caboose::StdClass.new({ :search_type => 'OpenHouse' , :remote_key_field => 'ID'         , :local_key_field => 'id'       , :local_table => 'rets_open_houses'  , :date_modified_field => 'DATE_MODIFIED'    })
-      when 'GFX' then Caboose::StdClass.new({ :search_type => 'Media'     , :remote_key_field => 'MEDIA_ID'   , :local_key_field => 'media_id' , :local_table => 'rets_media'        , :date_modified_field => 'DATE_MODIFIED'    })
-    end
+      when 'Office'    then Caboose::StdClass.new({ :search_type => 'Office'    , :remote_key_field => 'Matrix_Unique_ID' , :local_key_field => 'matrix_unique_id'    , :local_table => 'rets_offices'      , :date_modified_field => 'MatrixModifiedDT'})
+      when 'Agent'     then Caboose::StdClass.new({ :search_type => 'Agent'     , :remote_key_field => 'Matrix_Unique_ID' , :local_key_field => 'matrix_unique_id'    , :local_table => 'rets_agents'       , :date_modified_field => 'MatrixModifiedDT'})
+      when 'OpenHouse' then Caboose::StdClass.new({ :search_type => 'OpenHouse' , :remote_key_field => 'matrix_unique_id' , :local_key_field => 'matrix_unique_id'    , :local_table => 'rets_open_houses'  , :date_modified_field => 'MatrixModifiedDT'})
+      when 'Listing'   then Caboose::StdClass.new({ :search_type => 'Property'  , :remote_key_field => 'Matrix_Unique_ID' , :local_key_field => 'matrix_unique_id'    , :local_table => 'rets_properties'   , :date_modified_field => 'MatrixModifiedDT'})
+      when 'GFX'       then Caboose::StdClass.new({ :search_type => 'Media'     , :remote_key_field => 'MEDIA_ID'         , :local_key_field => 'media_id'            , :local_table => 'rets_media'        , :date_modified_field => 'DATE_MODIFIED'   })
+      end
   end
 
   #=============================================================================
   # Import method
   #=============================================================================
 
-  def self.import(class_type, query)    
+  def self.import(class_type, query)
     m = self.meta(class_type)
-    #self.log("Importing #{m.search_type}:#{class_type} with query #{query}...")
+    self.log("Importing #{m.search_type}:#{class_type} with query #{query}...")
     self.get_config if @@config.nil? || @@config['url'].nil?
     params = {
       :search_type => m.search_type,
       :class => class_type,
       :query => query,
-      :limit => -1,
       :timeout => -1
     }
     obj = nil
-    begin        
+
+    begin
       self.client.search(params) do |data|
         obj = self.get_instance_with_id(class_type, data)
         if obj.nil?
@@ -93,30 +90,23 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
       self.log "Import error for #{class_type}: #{query}"
       self.log err.message
     end
-    
   end
 
   def self.get_instance_with_id(class_type, data)
     obj = nil
     m = case class_type
-      when 'OPH' then CabooseRets::OpenHouse
-      when 'GFX' then CabooseRets::Media
-      when 'COM' then CabooseRets::CommercialProperty
-      when 'LND' then CabooseRets::LandProperty
-      when 'MUL' then CabooseRets::MultiFamilyProperty
-      when 'RES' then CabooseRets::ResidentialProperty
-      when 'AGT' then CabooseRets::Agent
-      when 'OFF' then CabooseRets::Office
-    end
-    obj = case class_type
-      when 'OPH' then m.where(:id       => data['ID'].to_i       ).exists? ? m.where(:id       => data['ID'].to_i       ).first : m.new(:id       => data['ID'].to_i       )
-      when 'GFX' then m.where(:media_id => data['MEDIA_ID']      ).exists? ? m.where(:media_id => data['MEDIA_ID']      ).first : m.new(:media_id => data['MEDIA_ID']      )
-      when 'COM' then m.where(:id       => data['MLS_ACCT'].to_i ).exists? ? m.where(:id       => data['MLS_ACCT'].to_i ).first : m.new(:id       => data['MLS_ACCT'].to_i )
-      when 'LND' then m.where(:id       => data['MLS_ACCT'].to_i ).exists? ? m.where(:id       => data['MLS_ACCT'].to_i ).first : m.new(:id       => data['MLS_ACCT'].to_i )
-      when 'MUL' then m.where(:id       => data['MLS_ACCT'].to_i ).exists? ? m.where(:id       => data['MLS_ACCT'].to_i ).first : m.new(:id       => data['MLS_ACCT'].to_i )
-      when 'RES' then m.where(:id       => data['MLS_ACCT'].to_i ).exists? ? m.where(:id       => data['MLS_ACCT'].to_i ).first : m.new(:id       => data['MLS_ACCT'].to_i )
-      when 'AGT' then m.where(:la_code  => data['LA_LA_CODE']    ).exists? ? m.where(:la_code  => data['LA_LA_CODE']    ).first : m.new(:la_code  => data['LA_LA_CODE']    )
-      when 'OFF' then m.where(:lo_code  => data['LO_LO_CODE']    ).exists? ? m.where(:lo_code  => data['LO_LO_CODE']    ).first : m.new(:lo_code  => data['LO_LO_CODE']    )
+      when 'Listing'   then CabooseRets::Property
+      when 'OpenHouse' then CabooseRets::OpenHouse
+      when 'Agent'     then CabooseRets::Agent
+      when 'Office'    then CabooseRets::Office
+      when 'GFX'       then CabooseRets::Media
+    end  
+    obj  = case class_type
+      when 'Listing'   then m.where(:matrix_unique_id => data['Matrix_Unique_ID']).exists? ? m.where(:matrix_unique_id => data['Matrix_Unique_ID']).first : m.new(:matrix_unique_id => data['Matrix_Unique_ID'])
+      when 'OpenHouse' then m.where(:matrix_unique_id => data['matrix_unique_id']).exists? ? m.where(:matrix_unique_id => data['matrix_unique_id']).first : m.new(:matrix_unique_id => data['matrix_unique_id'])
+      when 'Agent'     then m.where(:matrix_unique_id => data['Matrix_Unique_ID']).exists? ? m.where(:matrix_unique_id => data['Matrix_Unique_ID']).first : m.new(:matrix_unique_id => data['Matrix_Unique_ID'])
+      when 'Office'    then m.where(:matrix_unique_id => data['Matrix_Unique_ID']).exists? ? m.where(:matrix_unique_id => data['Matrix_Unique_ID']).first : m.new(:matrix_unique_id => data['Matrix_Unique_ID'])
+      when 'GFX'       then m.where(:media_id => data['MEDIA_ID']      ).exists? ? m.where(:media_id => data['MEDIA_ID']      ).first : m.new(:media_id => data['MEDIA_ID']      )
     end
     return obj
   end
@@ -126,36 +116,32 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
   #=============================================================================
 
   def self.update_after(date_modified, save_images = true)
-    self.delay(:queue => 'rets').update_helper('RES', date_modified, save_images)
-    self.delay(:queue => 'rets').update_helper('COM', date_modified, save_images)
-    self.delay(:queue => 'rets').update_helper('LND', date_modified, save_images)
-    self.delay(:queue => 'rets').update_helper('MUL', date_modified, save_images)
-    self.delay(:queue => 'rets').update_helper('OFF', date_modified, save_images)
-    self.delay(:queue => 'rets').update_helper('AGT', date_modified, save_images)
-    self.delay(:queue => 'rets').update_helper('OPH', date_modified, save_images)
+    self.delay(:queue => 'rets').update_helper('Listing'  , date_modified, save_images)
+    self.delay(:queue => 'rets').update_helper('Office'   , date_modified, save_images)
+    self.delay(:queue => 'rets').update_helper('Agent'    , date_modified, save_images)
+    self.delay(:queue => 'rets').update_helper('OpenHouse', date_modified, save_images)
   end
 
-  def self.update_helper(class_type, date_modified, save_images = true)
+  def self.update_helper(class_type, date_modified, save_images = true)    
     m = self.meta(class_type)
-    k = m.remote_key_field    
-    d = date_modified.in_time_zone(CabooseRets::timezone).strftime("%FT%T")    
+    k = m.remote_key_field
+    d = date_modified.in_time_zone(CabooseRets::timezone).strftime("%FT%T")
     params = {
       :search_type => m.search_type,
       :class => class_type,
       :select => [m.remote_key_field],
+      :querytype => 'DMQL2',
       :query => "(#{m.date_modified_field}=#{d}+)",
       :standard_names_only => true,
       :timeout => -1
-    }
-    self.client.search(params) do |data|
+    }    
+    self.log(params)
+    self.client.search(params) do |data|    
       case class_type
-        when 'RES' then self.delay(:priority => 10, :queue => 'rets').import_residential_property(  data[k], save_images)
-        when 'COM' then self.delay(:priority => 10, :queue => 'rets').import_commercial_property(   data[k], save_images)
-        when 'LND' then self.delay(:priority => 10, :queue => 'rets').import_land_property(         data[k], save_images)
-        when 'MUL' then self.delay(:priority => 10, :queue => 'rets').import_multi_family_property( data[k], save_images)
-        when 'OFF' then self.delay(:priority => 10, :queue => 'rets').import_office(                data[k], save_images)
-        when 'AGT' then self.delay(:priority => 10, :queue => 'rets').import_agent(                 data[k], save_images)
-        when 'OPH' then self.delay(:priority => 10, :queue => 'rets').import_open_house(            data[k], save_images)
+        when 'Listing'   then self.delay(:priority => 10, :queue => 'rets').import_properties(data[k], save_images)
+        when 'Office'    then self.delay(:priority => 10, :queue => 'rets').import_office(    data[k], save_images)
+        when 'Agent'     then self.delay(:priority => 10, :queue => 'rets').import_agent(     data[k], save_images)
+        when 'OpenHouse' then self.delay(:priority => 10, :queue => 'rets').import_open_house(data[k], save_images)
       end
     end
   end
@@ -164,115 +150,116 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
   # Single model import methods (called from a worker dyno)
   #=============================================================================
 
-  def self.import_property(mls_acct, save_images = true)
-    self.import('RES', "(MLS_ACCT=*#{mls_acct}*)")
-    p = CabooseRets::ResidentialProperty.where(:id => mls_acct.to_i).first
-    if p.nil?
-      self.import('COM', "(MLS_ACCT=*#{mls_acct}*)")
-      p = CabooseRets::CommercialProperty.where(:id => mls_acct.to_i).first
-      if p.nil?
-        self.import('LND', "(MLS_ACCT=*#{mls_acct}*)")
-        p = CabooseRets::LandProperty.where(:id => mls_acct.to_i).first
-        if p.nil?
-          self.import('MUL', "(MLS_ACCT=*#{mls_acct}*)")
-          p = CabooseRets::MultiFamilyProperty.where(:id => mls_acct.to_i).first
-          return if p.nil?
-        end
-      end
+  # def self.import_property(mui, save_images = true)
+  #   self.import('Listinng', "(Matrix_Unique_ID=*#{mui}*)")
+  #   p = CabooseRets::Property.where(:id => id.to_i).first
+  #   self.download_property_images(p, save_images)
+  # end
+
+  def self.import_properties(mui, save_images = true)
+    self.import('Listing', "(Matrix_Unique_ID=#{mui})")
+    p = CabooseRets::Property.where(:matrix_unique_id => mui.to_s).first
+    # p = CabooseRets::Property.create(:matrix_unique_id => mui.to_s) if p.nil?
+    if p != nil
+      self.download_property_images(p)
+      self.update_coords(p)
+    else
+      self.log("No Property associated with #{mui}")
     end
-    self.download_property_images(p, save_images)
-  end
-
-  def self.import_residential_property(mls_acct, save_images = true)
-    self.import('RES', "(MLS_ACCT=*#{mls_acct}*)")
-    p = CabooseRets::ResidentialProperty.where(:id => mls_acct.to_i).first
-    self.download_property_images(p, save_images)
-    self.update_coords(p)
-  end
-
-  def self.import_commercial_property(mls_acct, save_images = true)
-    self.import('COM', "(MLS_ACCT=*#{mls_acct}*)")
-    p = CabooseRets::CommercialProperty.where(:id => mls_acct.to_i).first
-    self.download_property_images(p, save_images)
-    self.update_coords(p)
-  end
-
-  def self.import_land_property(mls_acct, save_images = true)
-    self.import('LND', "(MLS_ACCT=*#{mls_acct}*)")
-    p = CabooseRets::LandProperty.where(:id => mls_acct.to_i).first
-    self.download_property_images(p, save_images)
-    self.update_coords(p)
-  end
-
-  def self.import_multi_family_property(mls_acct, save_images = true)
-    self.import('MUL', "(MLS_ACCT=*#{mls_acct}*)")
-    p = CabooseRets::MultiFamilyProperty.where(:id => mls_acct.to_i).first
-    self.download_property_images(p, save_images)
-    self.update_coords(p)
   end
 
-  def self.import_office(lo_code, save_images = true)    
-    self.import('OFF', "(LO_LO_CODE=*#{lo_code}*)")
-    office = CabooseRets::Office.where(:lo_code => lo_code.to_s).first
-    self.download_office_image(office) if save_images == true
+  def self.import_office(mui, save_images = true)
+    self.import('Office', "(matrix_unique_id=#{mui})")
+    office = CabooseRets::Office.where(:matrix_unique_id => mui.to_s).first
+    # self.download_office_image(office) if save_images == true
   end
 
-  def self.import_agent(la_code, save_images = true)
-    self.import('AGT', "(LA_LA_CODE=*#{la_code}*)")
-    a = CabooseRets::Agent.where(:la_code => la_code.to_s).first
-    self.download_agent_image(a) #if save_images == true
+  def self.import_agent(mui, save_images = true)
+    self.import('Agent', "(Matrix_Unique_ID=#{mui})")
+    a = CabooseRets::Agent.where(:matrix_unique_id => mui.to_s).first
+    # self.download_agent_image(a) #if save_images == true
   end
 
-  def self.import_open_house(id, save_images = true)
-    self.import('OPH', "((ID=#{id}+),(ID=#{id}-))")
+  def self.import_open_house(mui, save_images = true)
+    self.import('OpenHouse', "(Matrix_Unique_ID=#{mui})")
   end
 
   def self.import_media(id, save_images = true)
-    self.import('GFX', "((MEDIA_ID=#{id}+),(MEDIA_ID=#{id}-))")        
+    self.import('GFX', "((MEDIA_ID=#{id}+),(MEDIA_ID=#{id}-))")
   end
 
   #=============================================================================
   # Images
   #=============================================================================
-    
-  def self.download_property_images(p, save_images = true)
-    return if save_images == false
-    
-    self.log("- Downloading GFX records for #{p.mls_acct}...")
-    params = {
-      :search_type => 'Media',
-      :class => 'GFX',      
-      :query => "(MLS_ACCT=*#{p.mls_acct}*)",
-      :timeout => -1
-    }
-    ids = []
-    self.client.search(params) do |data|
-      ids << data['MEDIA_ID']      
-      m = CabooseRets::Media.where(:media_id => data['MEDIA_ID']).first
-      m = CabooseRets::Media.new if m.nil?             
-      m.parse(data)      
-      m.save
-    end
-    
-    if ids.count > 0
-      # Delete any records in the local database that shouldn't be there    
-      self.log("- Deleting GFX records for MLS ##{p.mls_acct} in the local database that are not in the remote database...")
-      query = "select media_id from rets_media where mls_acct = '#{p.mls_acct}'"
-      rows = ActiveRecord::Base.connection.select_all(ActiveRecord::Base.send(:sanitize_sql_array, query))
-      local_ids = rows.collect{ |row| row['media_id'] }
-      ids_to_remove = local_ids - ids
-      if ids_to_remove && ids_to_remove.count > 0
-        query = ["delete from rets_media where media_id in (?)", ids_to_remove]
-        ActiveRecord::Base.connection.execute(ActiveRecord::Base.send(:sanitize_sql_array, query))
+
+  # def self.download_property_images(p, save_images = true)
+  #   return if save_images == false
+
+  #   self.log("- Downloading GFX records for #{p.matrix_unique_id}...")
+  #   params = {
+  #     :search_type => 'Media',
+  #     :class => 'Photo',
+  #     :type => 'Photo',
+  #     :resource => 'Property',
+  #     :query => "(ID=*#{p.matrix_unique_id}:1*)",
+  #     :limit => 1000,
+  #     :timeout => -1
+  #   }
+  #   ids = []
+  #   self.client.search(params) do |data|
+  #     puts data
+  #     ids << data['MEDIA_ID']
+  #     m = CabooseRets::Media.where(:media_id => data['MEDIA_ID']).first
+  #     m = CabooseRets::Media.new if m.nil?
+  #     data.MEDIA_MUI = p.matrix_unique_id
+  #     m.parse(data)
+  #     m.save
+  #   end
+
+  #   if ids.count > 0
+  #     # Delete any records in the local database that shouldn't be there
+  #     self.log("- Deleting GFX records for MLS ##{p.matrix_unique_id} in the local database that are not in the remote database...")
+  #     query = "select media_id from rets_media where matrix_unique_id = '#{p.matrix_unique_id}'"
+  #     rows = ActiveRecord::Base.connection.select_all(ActiveRecord::Base.send(:sanitize_sql_array, query))
+  #     local_ids = rows.collect{ |row| row['media_id'] }
+  #     ids_to_remove = local_ids - ids
+  #     if ids_to_remove && ids_to_remove.count > 0
+  #       query = ["delete from rets_media where media_id in (?)", ids_to_remove]
+  #       ActiveRecord::Base.connection.execute(ActiveRecord::Base.send(:sanitize_sql_array, query))
+  #     end
+  #   end
+  # end
+
+  def self.download_property_images(p)
+    self.log "Saving images for #{p.matrix_unique_id}..."
+    i=0
+    begin
+      url = "http://rets.wamls.mlsmatrix.com/rets/GetObject.ashx?Type=Photo&Resource=Property&ID=1026514:1"
+      self.client.get_object(:resource => 'Property', :type => 'Photo', :location=> false, :id => '1026514:*') do |headers, content|        
+        m = CabooseRets::Media.where(:media_mui => headers['object-id']).first
+        m = CabooseRets::Media.new if m.nil? 
+        m.media = Caboose::Media.new
+        File.open("temp_img_#{p.matrix_unique_id}_#{i}.jpeg", "wb") do |f| 
+          f.write(content)
+        end
+        m.media.image = File.open("temp_img_#{p.matrix_unique_id}_#{i}.jpeg")
+        m.media_type = headers['content_type']
+        m.media_mui  = headers['media_mui']       
+        m.media.save
+        m.save
+        self.log("Image #{p.matrix_unique_id}"+ ":#{i} saved")
+        i += 1
       end
+    rescue RETS::APIError => err
+      self.log "No image for #{p.matrix_unique_id}."
+      self.log err
     end
-        
   end
-  
+
   def self.download_agent_image(agent)
     self.log "Saving image for #{agent.first_name} #{agent.last_name}..."
     begin
-      self.client.get_object(:resource => :Agent, :type => :Photo, :location => true, :id => agent.la_code) do |headers, content|
+      self.client.get_object(:resource => :Agent, :type => :Photo, :location => true, :id => property.list_agent_mls_id) do |headers, content|
         agent.verify_meta_exists
         agent.meta.image_location = headers['location']
         agent.meta.save
@@ -282,7 +269,7 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
       self.log err
     end
   end
-  
+
   def self.download_office_image(office)
     #self.log "Saving image for #{agent.first_name} #{agent.last_name}..."
     #begin
@@ -303,23 +290,19 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
 
   def self.update_coords(p = nil)
     if p.nil?
-      models = [CabooseRets::CommercialProperty, CabooseRets::LandProperty, CabooseRets::MultiFamilyProperty, CabooseRets::ResidentialProperty]
-      names = ["commercial", "land", "multi-family", "residential"]
-      i = 0
-      models.each do |model|
-        self.log "Updating coords #{names[i]} properties..."
-        model.where(:latitude => nil).reorder(:mls_acct).each do |p|
-          self.delay(:queue => 'rets').update_coords(p)
+      model = CabooseRets::Property      
+      i = 0      
+        self.log "Updating coords properties..."
+        model.where(:latitude => nil).reorder(:matrix_unique_id).each do |p1|
+          self.delay(:queue => 'rets').update_coords(p1)
         end
-        i = i + 1
-      end
       return
     end
 
-    self.log "Getting coords for mls_acct #{p.mls_acct}..."
-    coords = self.coords_from_address(CGI::escape "#{p.street_num} #{p.street_name}, #{p.city}, #{p.state} #{p.zip}")
+    self.log "Getting coords for Matrix_Unique_ID #{p.matrix_unique_id}..."
+    coords = self.coords_from_address(CGI::escape "#{p.street_number} #{p.street_name}, #{p.city}, #{p.state_or_province} #{p.postal_code}")
     if coords.nil? || coords == false
-      self.log "Can't set coords for mls acct #{p.mls_acct}..."
+      self.log "Can't set coords for Matrix_Unique_ID #{p.Matrix_Unique_ID}..."
       return
     end
 
@@ -348,30 +331,25 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
   #=============================================================================
 
   def self.purge
-    self.purge_residential
-    self.purge_commercial
-    self.purge_land
-    self.purge_multi_family
+    self.log('purging')
+    self.purge_properties
     self.purge_offices
     #self.purge_agents
     self.purge_open_houses
-    self.purge_media
-  end
-
-  def self.purge_residential()  self.delay(:queue => 'rets').purge_helper('RES', '2012-01-01') end
-  def self.purge_commercial()   self.delay(:queue => 'rets').purge_helper('COM', '2012-01-01') end
-  def self.purge_land()         self.delay(:queue => 'rets').purge_helper('LND', '2012-01-01') end
-  def self.purge_multi_family() self.delay(:queue => 'rets').purge_helper('MUL', '2012-01-01') end
-  def self.purge_offices()      self.delay(:queue => 'rets').purge_helper('OFF', '2012-01-01') end
-  def self.purge_agents()       self.delay(:queue => 'rets').purge_helper('AGT', '2012-01-01') end
-  def self.purge_open_houses()  self.delay(:queue => 'rets').purge_helper('OPH', '2012-01-01') end
-  def self.purge_media()        self.delay(:queue => 'rets').purge_helper('GFX', '2012-01-01') end
+  end  
+  
+  def self.purge_properties()   self.delay(:queue => 'rets').purge_helper('Listing', '2012-01-01') end
+  def self.purge_offices()      self.delay(:queue => 'rets').purge_helper('Office', '2012-01-01') end
+  def self.purge_agents()       self.delay(:queue => 'rets').purge_helper('Agent', '2012-01-01') end
+  def self.purge_open_houses()  self.delay(:queue => 'rets').purge_helper('OpenHouse', '2012-01-01') end
+  
 
-  def self.purge_helper(class_type, date_modified)
-    m = self.meta(class_type)
+  def self.purge_helper(class_type, date_modified)    
+    m = self.meta(class_type)    
+    self.log(m.search_type)
 
     self.log("Purging #{class_type}...")
-    
+
     # Get the total number of records
     self.log("- Getting total number of records for #{class_type}...")
     params = {
@@ -381,35 +359,36 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
       :standard_names_only => true,
       :timeout => -1
     }
-    self.client.search(params.merge({ :count_mode => :only }))
-    count = self.client.rets_data[:code] == "20201" ? 0 : self.client.rets_data[:count]
+    count = 0
+    self.client.search(params.merge({ :count => 1})) do |data| end        
+    count = self.client.rets_data[:code] == "20201" ? 0 : self.client.rets_data[:count]    
     batch_count = (count.to_f/5000.0).ceil
-    
+
     ids = []
     k = m.remote_key_field
     (0...batch_count).each do |i|
       self.log("- Getting ids for #{class_type} (batch #{i+1} of #{batch_count})...")
-      self.client.search(params.merge({ :select => [k], :limit => 5000, :offset => 5000*i })) do |data|                
-        ids << (class_type == 'OPH' ? data[k].to_i : data[k])        
-      end      
-    end    
+      self.client.search(params.merge({ :select => [k], :limit => 5000, :offset => 5000*i })) do |data|
+        ids << (class_type == 'OpenHouse' ? data[k].to_i : data[k])
+      end
+    end
 
-    # Only do stuff if we got a real response from the server    
+    # Only do stuff if we got a real response from the server
     if ids.count > 0
-      
+
       # Delete any records in the local database that shouldn't be there
-      self.log("- Finding #{class_type} records in the local database that are not in the remote database...")    
+      self.log("- Finding #{class_type} records in the local database that are not in the remote database...")
       t = m.local_table
-      k = m.local_key_field        
+      k = m.local_key_field
       query = "select distinct #{k} from #{t}"
       rows = ActiveRecord::Base.connection.select_all(ActiveRecord::Base.send(:sanitize_sql_array, query))
       local_ids = rows.collect{ |row| row[k] }
-      ids_to_remove = local_ids - ids    
+      ids_to_remove = local_ids - ids
       self.log("- Found #{ids_to_remove.count} #{class_type} records in the local database that are not in the remote database.")
       self.log("- Deleting #{class_type} records in the local database that shouldn't be there...")
       query = ["delete from #{t} where #{k} in (?)", ids_to_remove]
       ActiveRecord::Base.connection.execute(ActiveRecord::Base.send(:sanitize_sql_array, query))
-    
+
       # Find any ids in the remote database that should be in the local database
       self.log("- Finding #{class_type} records in the remote database that should be in the local database...")
       query = "select distinct #{k} from #{t}"
@@ -421,21 +400,15 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
       ids_to_add.each do |id|
         self.log("- Importing #{id}...")
         case class_type
-          when 'RES' then self.delay(:queue => 'rets').import_residential_property(id, false)
-          when 'COM' then self.delay(:queue => 'rets').import_commercial_property(id, false)
-          when 'LND' then self.delay(:queue => 'rets').import_land_property(id, false)
-          when 'MUL' then self.delay(:queue => 'rets').import_multi_family_property(id, false)
-          when 'OFF' then self.delay(:queue => 'rets').import_office(id, false)
-          when 'AGT' then self.delay(:queue => 'rets').import_agent(id, false)
-          when 'OPH' then self.delay(:queue => 'rets').import_open_house(id, false)
-          when 'GFX' then self.delay(:queue => 'rets').import_media(id, false)
+          when "Listing"   then self.delay(:queue => 'rets').import_properties(id, false)
+          when "Office"    then self.delay(:queue => 'rets').import_office(id, false)
+          when "Agent"     then self.delay(:queue => 'rets').import_agent(id, false)
+          when "OpenHouse" then self.delay(:queue => 'rets').import_open_house(id, false)
         end
       end
-      
     end
-
   end
-  
+
   def self.get_media_urls
     m = self.meta(class_type)
 
@@ -443,11 +416,11 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
     params = {
       :search_type => m.search_type,
       :class => class_type,
-      :query => "(#{m.date_modified_field}=#{date_modified}T00:00:01+)",
+      :query => "(#{m.matrix_modified_dt}=#{date_modified}T00:00:01+)",
       :standard_names_only => true,
       :timeout => -1
     }
-    self.client.search(params.merge({ :count_mode => :only }))
+    self.client.search(params.merge({ :count => 1 }))
     count = self.client.rets_data[:code] == "20201" ? 0 : self.client.rets_data[:count]
     batch_count = (count.to_f/5000.0).ceil
 
@@ -455,16 +428,7 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
     k = m.remote_key_field
     (0...batch_count).each do |i|
       self.client.search(params.merge({ :select => [k], :limit => 5000, :offset => 5000*i })) do |data|
-        ids << case class_type
-          when 'RES' then data[k] 
-          when 'COM' then data[k] 
-          when 'LND' then data[k] 
-          when 'MUL' then data[k] 
-          when 'OFF' then data[k]  
-          when 'AGT' then data[k]
-          when 'OPH' then data[k].to_i
-          when 'GFX' then data[k]
-        end                
+        ids << data[k]
       end
     end
 
@@ -474,23 +438,19 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
       k = m.local_key_field
       query = ["delete from #{t} where #{k} not in (?)", ids]
       ActiveRecord::Base.connection.execute(ActiveRecord::Base.send(:sanitize_sql_array, query))
-    
+
       # Find any ids in the remote database that should be in the local database
-      query = "select distinct #{k} from #{t}"
+      query = "select distinct #{k} from #{t}"      
       rows = ActiveRecord::Base.connection.select_all(ActiveRecord::Base.send(:sanitize_sql_array, query))
       local_ids = rows.collect{ |row| row[k] }
       ids_to_add = ids - local_ids
       ids_to_add.each do |id|
         self.log("Importing #{id}...")
         case class_type
-          when 'RES' then self.delay(:queue => 'rets').import_residential_property(id, false)
-          when 'COM' then self.delay(:queue => 'rets').import_commercial_property(id, false)
-          when 'LND' then self.delay(:queue => 'rets').import_land_property(id, false)
-          when 'MUL' then self.delay(:queue => 'rets').import_multi_family_property(id, false)
-          when 'OFF' then self.delay(:queue => 'rets').import_office(id, false)
-          when 'AGT' then self.delay(:queue => 'rets').import_agent(id, false)
-          when 'OPH' then self.delay(:queue => 'rets').import_open_house(id, false)
-          when 'GFX' then self.delay(:queue => 'rets').import_media(id)
+          when "Listing"   then self.delay(:queue => 'rets').import_properties(id, false)
+          when "Office"    then self.delay(:queue => 'rets').import_office(id, false)
+          when "Agent"     then self.delay(:queue => 'rets').import_agent(id, false)
+          when "OpenHouse" then self.delay(:queue => 'rets').import_open_house(id, false)
         end
       end
     end
@@ -501,13 +461,13 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
   # Logging
   #=============================================================================
 
-  def self.log(msg)        
-    puts "[rets_importer] #{msg}"    
+  def self.log(msg)
+    puts "[rets_importer] #{msg}"
     #Rails.logger.info("[rets_importer] #{msg}")
   end
-  
+
   def self.log2(msg)
-    puts "======================================================================"    
+    puts "======================================================================"
     puts "[rets_importer] #{msg}"
     puts "======================================================================"
     #Rails.logger.info("[rets_importer] #{msg}")
@@ -518,7 +478,7 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
   #=============================================================================
 
   def self.update_rets
-    self.log2("Updating rets...")    
+    self.log2("Updating rets...")
     if self.task_is_locked
       self.log2("Task is locked, aborting.")
       return
@@ -527,20 +487,20 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
     task_started = self.lock_task
 
     begin
-      overlap = 30.seconds      
+      overlap = 30.seconds
       if (DateTime.now - self.last_purged).to_i >= 1
         self.purge
         self.save_last_purged(task_started)
         # Keep this in here to make sure all updates are caught
         #overlap = 1.month
       end
-      
+
       self.log2("Updating after #{self.last_updated.strftime("%FT%T%:z")}...")
       self.update_after(self.last_updated - overlap)
-      
+
       self.log2("Saving the timestamp for when we updated...")
 		  self.save_last_updated(task_started)
-		  
+
 		  self.log2("Unlocking the task...")
 		  self.unlock_task
 		rescue Exception => err
@@ -549,16 +509,16 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
 		ensure
 		  self.log2("Unlocking task if last updated...")
 		  self.unlock_task_if_last_updated(task_started)
-		end
+    end
 
 		# Start the same update process in five minutes
 		self.log2("Adding the update rets task for 5 minutes from now...")
 		q = "handler like '%update_rets%'"
-		count = Delayed::Job.where(q).count		 
+		count = Delayed::Job.where(q).count
 		if count == 0 || (count == 1 && Delayed::Job.where(q).first.locked_at)
 		  self.delay(:run_at => 5.minutes.from_now, :queue => 'rets').update_rets
 		end
-	end
+  end
 
   def self.last_updated
     if !Caboose::Setting.exists?(:name => 'rets_last_updated')
@@ -577,7 +537,7 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
   end
 
   def self.save_last_updated(d)
-    s = Caboose::Setting.where(:name => 'rets_last_updated').first    
+    s = Caboose::Setting.where(:name => 'rets_last_updated').first
     s.value = d.in_time_zone(CabooseRets::timezone).strftime("%FT%T%:z")
     s.save
   end
@@ -592,7 +552,7 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
     return Caboose::Setting.exists?(:name => 'rets_update_running')
   end
 
-  def self.lock_task    
+  def self.lock_task
     d = DateTime.now.utc.in_time_zone(CabooseRets::timezone)
     Caboose::Setting.create(:name => 'rets_update_running', :value => d.strftime("%FT%T%:z"))
     return d
@@ -607,4 +567,4 @@ class CabooseRets::RetsImporter # < ActiveRecord::Base
     self.unlock_task if setting && d.in_time_zone.strftime("%FT%T%:z") == setting.value
   end
 
-end
+end