caboose-rets 0.1.18 → 0.1.19

data/app/controllers/caboose_rets/rets_controller.rb

@@ -12,8 +12,8 @@ module CabooseRets
     def admin_import
       return if !user_is_allowed('properties', 'edit')
                   
-      mls_acct = params[:mls_acct].to_i
-      CabooseRets::RetsImporter.delay(:queue => 'rets').import_property(mls_acct)
+      mls = params[:mls].to_i
+      CabooseRets::RetsImporter.delay(:queue => 'rets').import_property(mls)
       
       resp = Caboose::StdClass.new
       resp.success = "The property is being imported from MLS.  This may take a few minutes depending on how many images it has."

data/app/controllers/caboose_rets/rets_media_controller.rb

@@ -9,39 +9,39 @@ module CabooseRets
       render :json => media_hash(m)
     end
   
-    # GET /admin/properties/:mls_acct/media    
+    # GET /admin/properties/:mls/media    
     def admin_property_media
       return if !user_is_allowed('media', 'view')      
-      @property = CabooseRets.get_property(params[:mls_acct])
+      @property = CabooseRets.get_property(params[:mls])
       render :layout => 'caboose/admin'
     end
     
-    # GET /admin/properties/:mls_acct/photos
+    # GET /admin/properties/:mls/photos
     def admin_photos
       return if !user_is_allowed('media', 'view')      
-      media = Media.where(:mls_acct => params[:mls_acct], :media_type => 'Photo').reorder(:media_order).all
+      media = Media.where(:mls => params[:mls], :media_type => 'Photo').reorder(:media_order).all
       media2 = media.collect { |m| media_hash(m) }      	      
       render :json => media2
     end
     
-    # GET /admin/properties/:mls_acct/files
+    # GET /admin/properties/:mls/files
     def admin_files
       return if !user_is_allowed('media', 'view')      
-      media = Media.where(:mls_acct => params[:mls_acct], :media_type => 'File').reorder(:media_order).all
+      media = Media.where(:mls => params[:mls], :media_type => 'File').reorder(:media_order).all
       media2 = media.collect { |m| media_hash(m) }      	      
       render :json => media2
     end
 
-    # POST /admin/properties/:mls_acct/photos
+    # POST /admin/properties/:mls/photos
     def admin_add_photo
       return if !user_is_allowed('media', 'edit')      
             
-      x = Media.maximum(:media_order, :conditions => {:mls_acct => params[:mls_acct], :media_type => 'Photo'})
+      x = Media.maximum(:media_order, :conditions => {:mls => params[:mls], :media_type => 'Photo'})
       x = 0 if x.nil?
       
       m = Media.new
       m.id            = Media.maximum(:id) + 1
-      m.mls_acct 		  = params[:mls_acct]
+      m.mls 		  = params[:mls]
       m.date_modified = DateTime.now                  
       m.media_order   = x + 1
       m.media_type 		= 'Photo'
@@ -55,12 +55,12 @@ module CabooseRets
     def admin_add_file
       return if !user_is_allowed('media', 'edit')
 
-      x = Media.maximum(:media_order, :conditions => {:mls_acct => params[:mls_acct], :media_type => 'File'})
+      x = Media.maximum(:media_order, :conditions => {:mls => params[:mls], :media_type => 'File'})
       x = 0 if x.nil?      
                   
       m = Media.new
       m.id            = Media.maximum(:id) + 1
-      m.mls_acct 		  = params[:mls_acct]
+      m.mls 		  = params[:mls]
       m.date_modified = DateTime.now                  
       m.media_order   = x + 1
       m.media_type 		= 'File'
@@ -77,7 +77,7 @@ module CabooseRets
       render :json => true
     end
     
-    # PUT /admin/properties/:mls_acct/media/order
+    # PUT /admin/properties/:mls/media/order
     def admin_update_order
       return if !user_is_allowed('media', 'delete')      
       Media.reorder(params[:sort], "advantagerealtygroup")            
@@ -95,7 +95,7 @@ module CabooseRets
         :media_order 	  => m.media_order,
         :media_remarks  => m.media_remarks,
         :media_type 		=> m.media_type,
-        :mls_acct 		  => m.mls_acct,
+        :mls 		  => m.mls,
         :url 		        => m.url,          
         :image => {
           :file_name    => m.image_file_name,

data/app/controllers/caboose_rets/saved_properties_controller.rb

@@ -1,88 +1,88 @@
 module CabooseRets  
   class SavedPropertiesController < ApplicationController
-     
+
     # GET /saved-properties
     def index
       return if !verify_logged_in
-      @properties = SavedProperty.where(:user_id => logged_in_user.id).all      
+      @properties = SavedProperty.where(:user_id => logged_in_user.id).all
     end
-  
+
     # POST /saved-properties
     def add
-      return if !verify_logged_in      
-      
+      return if !verify_logged_in
+
       resp = Caboose::StdClass.new
-      
-      if SavedProperty.exists?(:user_id => logged_in_user.id, :mls_acct => params[:mls_acct])
+
+      if SavedProperty.exists?(:user_id => logged_in_user.id, :mls => params[:mls])
         resp.success = true
-      else        
+      else
         p = SavedProperty.new(
           :user_id  => logged_in_user.id,
-          :mls_acct => params[:mls_acct]                  
+          :mls => params[:mls]
         )
         if p.save
-          resp.success = true        
+          resp.success = true
         else
-          resp.error = "There was an error saving your property."        
+          resp.error = "There was an error saving your property."
         end
       end
       render :json => resp
     end
-    
-    # DELETE /saved-properties/:mls_acct
+
+    # DELETE /saved-properties/:mls
     def delete
-      return if !verify_logged_in      
-      SavedProperty.where(:user_id => logged_in_user.id, :mls_acct => params[:mls_acct]).destroy_all       
+      return if !verify_logged_in
+      SavedProperty.where(:user_id => logged_in_user.id, :mls => params[:mls]).destroy_all
       render :json => Caboose::StdClass.new('success' => true)
     end
-    
+
     # POST /saved-properties
     def add
-      return if !verify_logged_in      
-      
+      return if !verify_logged_in
+
       resp = Caboose::StdClass.new
-      
-      if SavedProperty.exists?(:user_id => logged_in_user.id, :mls_acct => params[:mls_acct])
+
+      if SavedProperty.exists?(:user_id => logged_in_user.id, :mls => params[:mls])
         resp.success = true
-      else        
+      else
         p = SavedProperty.new(
           :user_id  => logged_in_user.id,
-          :mls_acct => params[:mls_acct]                  
+          :mls => params[:mls]
         )
         if p.save
-          resp.success = true        
+          resp.success = true
         else
-          resp.error = "There was an error saving your property."        
+          resp.error = "There was an error saving your property."
         end
       end
       render :json => resp
     end
-    
-    # GET /saved-properties/:mls_acct/toggle
+
+    # GET /saved-properties/:mls/toggle
     def toggle_save
       return if !verify_logged_in
-      
+
       resp = Caboose::StdClass.new
-      if SavedProperty.where(:user_id => logged_in_user.id, :mls_acct => params[:mls_acct]).exists?
-        SavedProperty.where(:user_id => logged_in_user.id, :mls_acct => params[:mls_acct]).destroy_all
+      if SavedProperty.where(:user_id => logged_in_user.id, :mls => params[:mls]).exists?
+        SavedProperty.where(:user_id => logged_in_user.id, :mls => params[:mls]).destroy_all
         resp.saved = false
       else
         p = SavedProperty.new
         p.user_id = logged_in_user.id
-        p.mls_acct = params[:mls_acct]
+        p.mls = params[:mls]
         p.save
         resp.saved = true
       end
-          
+
       render :json => resp
     end
-    
-    # GET /saved-properties/:mls_acct/status
+
+    # GET /saved-properties/:mls/status
     def status
       return if !verify_logged_in
-      
+
       resp = Caboose::StdClass.new
-      resp.saved = SavedProperty.where(:user_id => logged_in_user.id, :mls_acct => params[:mls_acct]).exists?          
+      resp.saved = SavedProperty.where(:user_id => logged_in_user.id, :mls => params[:mls]).exists?
       render :json => resp
     end
 

data/app/models/caboose_rets/agent.rb

@@ -1,24 +1,22 @@
-
 class CabooseRets::Agent < ActiveRecord::Base
   self.table_name = "rets_agents"  
   
-  has_one :meta, :class_name => 'AgentMeta', :primary_key => 'la_code', :foreign_key => 'la_code'
-  has_many :commercial_properties
-  has_many :residential_properties    
-  attr_accessible :id, :la_code
+  has_one :meta, :class_name => 'AgentMeta', :primary_key => 'matrix_unique_id', :foreign_key => 'matrix_unique_id'
+  has_many :properties
+  attr_accessible :id, :agent_number, :matrix_unique_id
   after_initialize :fix_name
   
   def image
     return nil if self.meta.nil?
     return self.meta.image
   end
-  
-  def assistants
-    CabooseRets::Agent.where(:assistant_to => self.la_code).reorder(:last_name, :first_name).all
-  end
+
+  # def assistants
+  #   CabooseRets::Agent.where(:assistant_to => self.mls_id).reorder(:last_name, :first_name).all
+  # end
 
   def office
-    CabooseRets::Office.where(:lo_code => self.lo_code).first
+    CabooseRets::Office.where(:lo_mls_id => self.mls_id).first
   end
   
   def fix_name
@@ -32,58 +30,47 @@ class CabooseRets::Agent < ActiveRecord::Base
   end
   
   def refresh_from_mls        
-    CabooseRets::RetsImporter.import("(MLS_ACCT=#{self.mls_acct})", 'Property', 'RES')
+    CabooseRets::RetsImporter.import('Listing',"(Matrix_Unique_ID=#{self.matrix_unique_id})")
     CabooseRets::RetsImporter.download_property_images(self)
   end
   
-  def self.refresh_from_mls(la_code)
-    CabooseRets::RetsImporter.import("(LA_LA_CODE=#{la_code})", 'Agent', 'AGT')
-    CabooseRets::RetsImporter.import_property(mls_acct)          
+  def self.refresh_from_mls(agent_number)
+    CabooseRets::RetsImporter.import('Agent', "(Agent_Number=#{self.agent_number})")
+    CabooseRets::RetsImporter.import_property(matrix_unique_id)          
   end
     
   def parse(data)
-    self.beeper_phone         = data['LA_BEEPER_PHONE']
-	  self.last_name            = data['LA_LAST_NAME']
-	  self.member_email         = data['LA_MEMBER_EMAIL']
-	  self.phone_home_fax       = data['LA_PHONE_HOME_FAX']
-	  self.car_phone            = data['LA_CAR_PHONE']
-	  self.la_code              = data['LA_LA_CODE']
-	  self.member_page          = data['LA_MEMBER_PAGE']
-	  self.phone_pager          = data['LA_PHONE_PAGER']
-	  self.date_created         = data['LA_DATE_CREATED']
-	  self.lo_code              = data['LA_LO_CODE']
-	  self.member_status        = data['LA_MEMBER_STATUS']
-	  self.phone_second_home    = data['LA_PHONE_SECOND_HOME']
-	  self.date_modified        = data['LA_DATE_MODIFIED']
-	  self.mail_addr1           = data['LA_MAIL_ADDR1']
-	  self.nrds_id              = data['LA_NRDS_ID']
-	  self.phone_toll_free      = data['LA_PHONE_TOLL_FREE']
-	  self.defaultemail         = data['LA_DEFAULTEMAIL']
-	  self.mail_addr2           = data['LA_MAIL_ADDR2']
-	  self.office_phone         = data['LA_OFFICE_PHONE']
-	  self.phone_voice_mail     = data['LA_PHONE_VOICE_MAIL']
-	  self.fax_phone            = data['LA_FAX_PHONE']
-	  self.mail_city            = data['LA_MAIL_CITY']
-	  self.other_phone          = data['LA_OTHER_PHONE']
-	  self.phone_voice_pager    = data['LA_PHONE_VOICE_PAGER']
-	  self.first_name           = data['LA_FIRST_NAME']
-	  self.mail_state           = data['LA_MAIL_STATE']
-	  self.phone_change_date    = data['LA_PHONE_CHANGE_DATE']
-	  self.photo_count          = data['PHOTO_COUNT']
-	  self.home_phone           = data['LA_HOME_PHONE']
-	  self.mail_zip             = data['LA_MAIL_ZIP']
-	  self.phone_direct_office  = data['LA_PHONE_DIRECT_OFFICE']
-	  self.photo_date_modified  = data['PHOTO_DATE_MODIFIED']
-	  #self.photo_url            = ""
-	end
-	
-	def verify_meta_exists
-	  self.meta = CabooseRets::AgentMeta.create(:la_code => self.la_code) if self.meta.nil?
-	end
-	
-	def image_url(style)	  	    	    
+    self.agent_number                 = data['AgentNumber']
+    self.cell_phone                   = data['CellPhone']
+    self.direct_work_phone            = data['DirectWorkPhone']
+    self.email                        = data['Email']
+    self.fax_phone                    = data['FaxPhone']
+    self.first_name                   = data['FirstName']
+    self.full_name                    = data['FullName']
+    self.generational_name            = data['GenerationalName']
+    self.last_name                    = data['LastName']
+    self.matrix_unique_id             = data['Matrix_Unique_ID']
+    self.matrix_modified_dt           = data['MatrixModifiedDT']
+    self.middle_name                  = data['MiddleName']
+    self.mls                          = data['MLS']
+    self.mls_id                       = data['MLSID']
+    self.office_mui                   = data['Office_MUI']
+    self.office_mls_id                = data['OfficeMLSID']
+    self.office_phone                 = data['OfficePhone']
+    self.other_phone                  = data['OtherPhone']
+    self.phone_toll_free              = data['PhoneTollFree']
+    self.phone_voice_mail             = data['PhoneVoiceMail']        
+    self.photo_count                  = data['PhotoCount']
+    self.photo_modification_timestamp = data['PhotoModificationTimestamp'] 
+  end
+  
+  def verify_meta_exists
+     self.meta = CabooseRets::AgentMeta.create(:la_code => self.la_code) if self.meta.nil?
+  end
+  
+  def image_url(style)                
     if CabooseRets::use_hosted_images == true
-      #return "#{CabooseRets::agents_base_url}/#{self.image_location}"
+      return "#{CabooseRets::agents_base_url}/#{self.image_location}"
       self.verify_meta_exists      
       return self.meta.image_location
     end

data/app/models/caboose_rets/agent_meta.rb

@@ -1,21 +1,21 @@
 
 class CabooseRets::AgentMeta < ActiveRecord::Base
-  self.table_name = "rets_agents_meta"  
-  belongs_to :agent, :foreign_key => 'la_code', :primary_key => 'la_code'
-  has_attached_file :image, 
-    :path => 'rets/agents/:la_code_:style.:extension', 
+  self.table_name = "rets_agents_meta"
+  belongs_to :agent, :foreign_key => 'matrix_unique_id', :primary_key => 'la_code'
+  has_attached_file :image,
+    :path => 'rets/agents/:la_code_:style.:extension',
     :styles => {
       :thumb => '100x150>',
       :large => '200x300>'
     }
   do_not_validate_attachment_file_type :image
-  attr_accessible :id, 
+  attr_accessible :id,
     :la_code         ,
-    :hide            , 
+    :hide            ,
     :bio             ,
     :contact_info    ,
     :assistant_to    ,
     :designation     ,
     :image_location
-    
+
 end

data/app/models/caboose_rets/media.rb

@@ -2,133 +2,139 @@
 class CabooseRets::Media < ActiveRecord::Base
   self.table_name = "rets_media"
   
-  has_attached_file :file, :path => 'rets/media/:mls_acct_:id.:extension'
+  has_attached_file :file, :path => 'rets/media/:mls_:id.:extension'
   do_not_validate_attachment_file_type :file
-  has_attached_file :image, 
-    :path => 'rets/media/:mls_acct_:media_order_:style.:extension', 
+  has_attached_file :image,
+    :path => 'rets/media/:mls_:media_order_:style.:extension',
     :styles => {
       :tiny  => '160x120>',
       :thumb => '400x300>',
       :large => '640x480>'
     }
   do_not_validate_attachment_file_type :image
-  attr_accessible :date_modified, :file_name, :media_id, :media_order, :media_remarks, :media_type, :mls_acct, :url
-  
-  def parse(data)
-    self.date_modified  = data['DATE_MODIFIED']
-    self.file_name 		  = data['FILE_NAME']
-    self.media_id 		  = data['MEDIA_ID']
-    self.media_order 	  = data['MEDIA_ORDER'].to_i
-    self.media_remarks  = data['MEDIA_REMARKS']
-    self.media_type 		= data['MEDIA_TYPE']
-    self.mls_acct 		  = data['MLS_ACCT']
-    self.url 		        = data['URL']
+  attr_accessible :date_modified, :file_name, :media_id, :media_order, :media_remarks, :media_type, :mls, :url
+
+  def parse(data,content)
+    # self.date_modified  = data['DATE_MODIFIED']
+    # self.file_name 		  = data['FILE_NAME']
+    # self.media_id 		  = data['MEDIA_ID']
+    # self.media_order 	  = data['MEDIA_ORDER'].to_i
+    # self.media_remarks  = data['MEDIA_REMARKS']    
+    # self.mls 		        = data['MLS']
+    self.media_type      = data['content-type']
+    self.media_mui       = data['content-id']
+    self.media           = Caboose::Media.create(
+                  :image => content,
+    #               :image => content,
+                  :image_content_type => data['content-type']
+          )
+    # self.media.save      
 	end
-	
+
 	before_post_process :lowercase_file_names
-  
-  def lowercase_file_names    
-    self.image.instance_write(:file_name, self.image_file_name.downcase) if self.image_file_name 
-    self.file.instance_write(:file_name, self.file_file_name.downcase)   if self.file_file_name    
+
+  def lowercase_file_names
+    self.image.instance_write(:file_name, self.image_file_name.downcase) if self.image_file_name
+    self.file.instance_write(:file_name, self.file_file_name.downcase)   if self.file_file_name
   end
 
-  #before_post_process :rename_avatar    
-  #def rename_image    
-  #  extension = File.extname(image_file_name).downcase    
-  #  self.image.instance_write :file_name, "#{self.mls_acct}_#{self.media_order}.#{extension}"
+  #before_post_process :rename_avatar
+  #def rename_image
+  #  extension = File.extname(image_file_name).downcase
+  #  self.image.instance_write :file_name, "#{self.mls}_#{self.media_order}.#{extension}"
   #end
-  
+
   def self.reorder(media_ids, bucket_name)
-    
+
     s3 = AWS::S3.new
     b = s3.buckets[bucket_name]
-    
+
     # Rename the s3 assets to temp names
     media_ids.each do |id|
-      m = CabooseRets::Media.find(id) 
+      m = CabooseRets::Media.find(id)
       (m.image.styles.keys+[:original]).each { |style| b.objects[m.image.path(style)].rename_to "#{m.image.path(style)}.temp" } if m.media_type == 'Photo'
       b.objects[m.file.path].rename_to "#{m.file.path}.temp" if m.media_type == 'File'
     end
-    
+
     # Rename the assets to their new names
     i = 1
     j = 1
     media_ids.each do |id|
       m = CabooseRets::Media.find(id)
-      if m.media_type == 'Photo'        
-        orig_name = "#{m.image.path}.temp"        
-        m.media_order = i      
-        (m.image.styles.keys+[:original]).each { |style| b.objects[orig_name.gsub("original", style.to_s)].rename_to m.image.path(style) }                
+      if m.media_type == 'Photo'
+        orig_name = "#{m.image.path}.temp"
+        m.media_order = i
+        (m.image.styles.keys+[:original]).each { |style| b.objects[orig_name.gsub("original", style.to_s)].rename_to m.image.path(style) }
         m.save
         i = i + 1
-      elsif m.media_type == 'File'        
+      elsif m.media_type == 'File'
         b.objects["#{m.file.path}.temp"].rename_to m.file.path
         m.media_order = j
         m.save
         j = j + 1
       end
     end
-    
+
     return true
   end
-  
+
   def self.reorder(media_ids, bucket_name)
-    
+
     s3 = AWS::S3.new
     b = s3.buckets[bucket_name]
-    
+
     # Rename the s3 assets to temp names
     media_ids.each do |id|
-      m = CabooseRets::Media.find(id) 
+      m = CabooseRets::Media.find(id)
       (m.image.styles.keys+[:original]).each { |style| b.objects[m.image.path(style)].rename_to "#{m.image.path(style)}.temp" } if m.media_type == 'Photo'
       b.objects[m.file.path].rename_to "#{m.file.path}.temp" if m.media_type == 'File'
     end
-    
+
     # Rename the assets to their new names
     i = 1
     j = 1
     media_ids.each do |id|
       m = CabooseRets::Media.find(id)
-      if m.media_type == 'Photo'        
-        orig_name = "#{m.image.path}.temp"        
-        m.media_order = i      
-        (m.image.styles.keys+[:original]).each { |style| b.objects[orig_name.gsub("original", style.to_s)].rename_to m.image.path(style) }                
+      if m.media_type == 'Photo'
+        orig_name = "#{m.image.path}.temp"
+        m.media_order = i
+        (m.image.styles.keys+[:original]).each { |style| b.objects[orig_name.gsub("original", style.to_s)].rename_to m.image.path(style) }
         m.save
         i = i + 1
-      elsif m.media_type == 'File'        
+      elsif m.media_type == 'File'
         b.objects["#{m.file.path}.temp"].rename_to m.file.path
         m.media_order = j
         m.save
         j = j + 1
       end
     end
-    
+
     return true
   end
-  
+
   def self.rename_media
     s3 = AWS::S3.new
     b = s3.buckets["advantagerealtygroup"]
-    
-    CabooseRets::Media.where(:media_type => 'Photo').reorder("mls_acct, media_order").all.each do |m|
-      puts "Renaming #{m.mls_acct}_#{m.id}..."
+
+    CabooseRets::Media.where(:media_type => 'Photo').reorder("mls, media_order").all.each do |m|
+      puts "Renaming #{m.mls}_#{m.id}..."
       if m.image_file_name && m.image
         ext = File.extname(m.image_file_name)
-        (m.image.styles.keys+[:original]).each do |style|          
+        (m.image.styles.keys+[:original]).each do |style|
           b.objects[m.image.path(style)].copy_to "rets/media_new/#{m.id}_#{style}.#{ext}" if b.objects[m.image.path(style)].exists?
         end
       end
     end
-    
+
     return true
   end
-  
-  def image_url(style)    
-    if CabooseRets::use_hosted_images == true      
-      return "#{CabooseRets::media_base_url}/#{self.file_name}"    
+
+  def image_url(style)
+    if CabooseRets::use_hosted_images == true
+      return "#{CabooseRets::media_base_url}/#{self.file_name}"
     end
     return "" if self.image.nil?
-    return self.image.url(style)           
+    return self.image.url(style)
   end
-        
+
 end