fat_free_crm 0.11.3 → 0.11.4

data/app/models/entities/account_contact.rb

@@ -30,8 +30,9 @@
 class AccountContact < ActiveRecord::Base
   belongs_to :account
   belongs_to :contact
-  validates_presence_of :account_id, :contact_id
+  
+  has_paper_trail :meta => { :related => :contact }, :ignore => [ :id, :created_at, :updated_at, :contact_id ]
+  
+  validates :account_id, :presence => true
 
-  # has_paper_trail
 end
-

data/app/models/entities/account_opportunity.rb

@@ -34,4 +34,3 @@ class AccountOpportunity < ActiveRecord::Base
 
   has_paper_trail
 end
-

data/app/models/entities/campaign.rb

@@ -57,19 +57,20 @@ class Campaign < ActiveRecord::Base
   scope :created_by, lambda { |user| where('user_id = ?' , user.id) }
   scope :assigned_to, lambda { |user| where('assigned_to = ?', user.id) }
 
-  scope :text_search, lambda { |query|
-    query = query.gsub(/[^\w\s\-\.'\p{L}]/u, '').strip
-    where('upper(name) LIKE upper(?)', "%#{query}%")
-  }
+  scope :text_search, lambda { |query| search('name_cont' => query).result }
 
   uses_user_permissions
   acts_as_commentable
+  uses_comment_extensions
   acts_as_taggable_on :tags
   has_paper_trail :ignore => [ :subscribed_users ]
   has_fields
   exportable
   sortable :by => [ "name ASC", "target_leads DESC", "target_revenue DESC", "leads_count DESC", "revenue DESC", "starts_on DESC", "ends_on DESC", "created_at DESC", "updated_at DESC" ], :default => "created_at DESC"
 
+  has_ransackable_associations %w(leads opportunities tags activities emails comments tasks)
+  ransack_can_autocomplete
+
   validates_presence_of :name, :message => :missing_campaign_name
   validates_uniqueness_of :name, :scope => [ :user_id, :deleted_at ]
   validate :start_and_end_dates
@@ -77,8 +78,7 @@ class Campaign < ActiveRecord::Base
 
   # Default values provided through class methods.
   #----------------------------------------------------------------------------
-  def self.per_page ; 20     ; end
-  def self.outline  ; "long" ; end
+  def self.per_page ; 20 ; end
 
   # Attach given attachment to the campaign if it hasn't been attached already.
   #----------------------------------------------------------------------------
@@ -121,4 +121,3 @@ class Campaign < ActiveRecord::Base
   end
 
 end
-

data/app/models/entities/contact.rb

@@ -58,33 +58,45 @@ class Contact < ActiveRecord::Base
   has_many    :opportunities, :through => :contact_opportunities, :uniq => true, :order => "opportunities.id DESC"
   has_many    :tasks, :as => :asset, :dependent => :destroy#, :order => 'created_at DESC'
   has_one     :business_address, :dependent => :destroy, :as => :addressable, :class_name => "Address", :conditions => "address_type = 'Business'"
+  has_many    :addresses, :dependent => :destroy, :as => :addressable, :class_name => "Address" # advanced search uses this
   has_many    :emails, :as => :mediator
 
-  serialize :subscribed_users, Set
+  has_ransackable_associations %w(account opportunities tags activities emails addresses comments tasks)
+  ransack_can_autocomplete
 
-  accepts_nested_attributes_for :business_address, :allow_destroy => true
+  serialize :subscribed_users, Set
 
+  accepts_nested_attributes_for :business_address, :allow_destroy => true, :reject_if => proc {|attributes| Address.reject_address(attributes)}
+    
   scope :created_by, lambda { |user| { :conditions => [ "user_id = ?", user.id ] } }
   scope :assigned_to, lambda { |user| { :conditions => ["assigned_to = ?", user.id ] } }
 
   scope :text_search, lambda { |query|
-    query = query.gsub(/[^@\w\s\-\.'\p{L}]/u, '').strip
+    t = Contact.arel_table
     # We can't always be sure that names are entered in the right order, so we must
     # split the query into all possible first/last name permutations.
     name_query = if query.include?(" ")
-      query.name_permutations.map{ |first, last|
-        "(upper(first_name) LIKE upper('%#{first}%') AND upper(last_name) LIKE upper('%#{last}%'))"
-      }.join(" OR ")
+      scope, *rest = query.name_permutations.map{ |first, last|
+        t[:first_name].matches("%#{first}%").and(t[:last_name].matches("%#{last}%"))
+      }
+      rest.map{|r| scope = scope.or(r)} if scope
+      scope
     else
-      "upper(first_name) LIKE upper('%#{query}%') OR upper(last_name) LIKE upper('%#{query}%')"
+      t[:first_name].matches("%#{query}%").or(t[:last_name].matches("%#{query}%"))
     end
-    where("#{name_query} OR upper(email) LIKE upper(:m) OR upper(alt_email) LIKE upper(:m) OR phone LIKE :m OR mobile LIKE :m", :m => "%#{query}%")
+
+    other = t[:email].matches("%#{query}%").or(t[:alt_email].matches("%#{query}%"))
+    other = other.or(t[:phone].matches("%#{query}%")).or(t[:mobile].matches("%#{query}%"))
+    
+    where( name_query.nil? ? other : name_query.or(other) )
   }
 
   uses_user_permissions
   acts_as_commentable
+  uses_comment_extensions
   acts_as_taggable_on :tags
   has_paper_trail :ignore => [ :subscribed_users ]
+  
   has_fields
   exportable
   sortable :by => [ "first_name ASC",  "last_name ASC", "created_at DESC", "updated_at DESC" ], :default => "created_at DESC"
@@ -96,7 +108,6 @@ class Contact < ActiveRecord::Base
   # Default values provided through class methods.
   #----------------------------------------------------------------------------
   def self.per_page ; 20                  ; end
-  def self.outline  ; "long"              ; end
   def self.first_name_position ; "before" ; end
 
   #----------------------------------------------------------------------------
@@ -112,25 +123,19 @@ class Contact < ActiveRecord::Base
   # Backend handler for [Create New Contact] form (see contact/create).
   #----------------------------------------------------------------------------
   def save_with_account_and_permissions(params)
-    account = Account.create_or_select_for(self, params[:account], params[:users])
-    self.account_contact = AccountContact.new(:account => account, :contact => self) unless account.id.blank?
+    save_account(params)
     self.opportunities << Opportunity.find(params[:opportunity]) unless params[:opportunity].blank?
-    self.save_with_permissions(params[:users])
+    self.save
   end
 
   # Backend handler for [Update Contact] form (see contact/update).
   #----------------------------------------------------------------------------
   def update_with_account_and_permissions(params)
-    if params[:account][:id] == "" || params[:account][:name] == ""
-      self.account = nil # Contact is not associated with the account anymore.
-    else
-      account = Account.create_or_select_for(self, params[:account], params[:users])
-      if self.account != account and account.id.present?
-        self.account_contact = AccountContact.new(:account => account, :contact => self)
-      end
-    end
-    self.reload
-    self.update_with_permissions(params[:contact], params[:users])
+    save_account(params)
+    # Must set access before user_ids, because user_ids= method depends on access value.
+    self.access = params[:contact][:access] if params[:contact][:access]
+    self.attributes = params[:contact]
+    self.save
   end
 
   # Attach given attachment to the contact if it hasn't been attached already.
@@ -163,8 +168,18 @@ class Contact < ActiveRecord::Base
     %w(first_name last_name title source email alt_email phone mobile blog linkedin facebook twitter skype do_not_call background_info).each do |name|
       attributes[name] = model.send(name.intern)
     end
-
+    
     contact = Contact.new(attributes)
+    
+    # Set custom fields.
+    if model.class.respond_to?(:fields)
+      model.class.fields.each do |field|
+        if contact.respond_to?(field.name)
+          contact.send "#{field.name}=", model.send(field.name)
+        end
+      end
+    end
+    
     contact.business_address = Address.new(:street1 => model.business_address.street1, :street2 => model.business_address.street2, :city => model.business_address.city, :state => model.business_address.state, :zipcode => model.business_address.zipcode, :country => model.business_address.country, :full_address => model.business_address.full_address, :address_type => "Business") unless model.business_address.nil?
 
     # Save the contact only if the account and the opportunity have no errors.
@@ -173,7 +188,7 @@ class Contact < ActiveRecord::Base
       contact.account_contact = AccountContact.new(:account => account, :contact => contact) unless account.id.blank?
       contact.opportunities << opportunity unless opportunity.id.blank?
       if contact.access != "Lead" || model.nil?
-        contact.save_with_permissions(params[:users])
+        contact.save
       else
         contact.save_with_model_permissions(model)
       end
@@ -187,6 +202,19 @@ class Contact < ActiveRecord::Base
   def users_for_shared_access
     errors.add(:access, :share_contact) if self[:access] == "Shared" && !self.permissions.any?
   end
+  
+  # Handles the saving of related accounts
+  #----------------------------------------------------------------------------
+  def save_account(params)
+    if params[:account][:id] == "" || params[:account][:name] == ""
+      self.account = nil
+    else
+      account = Account.create_or_select_for(self, params[:account])
+      if self.account != account and account.id.present?
+        self.account_contact = AccountContact.new(:account => account, :contact => self)
+      end
+    end
+    self.reload unless self.new_record? # ensure the account association is updated
+  end
 
 end
-

data/app/models/entities/contact_opportunity.rb

@@ -35,4 +35,3 @@ class ContactOpportunity < ActiveRecord::Base
 
   # has_paper_trail
 end
-

data/app/models/entities/lead.rb

@@ -55,6 +55,7 @@ class Lead < ActiveRecord::Base
   has_one     :contact, :dependent => :nullify # On destroy keep the contact, but nullify its lead_id
   has_many    :tasks, :as => :asset, :dependent => :destroy#, :order => 'created_at DESC'
   has_one     :business_address, :dependent => :destroy, :as => :addressable, :class_name => "Address", :conditions => "address_type='Business'"
+  has_many    :addresses, :dependent => :destroy, :as => :addressable, :class_name => "Address" # advanced search uses this
   has_many    :emails, :as => :mediator
 
   serialize :subscribed_users, Set
@@ -69,19 +70,20 @@ class Lead < ActiveRecord::Base
   scope :created_by, lambda { |user| where('user_id = ?' , user.id) }
   scope :assigned_to, lambda { |user| where('assigned_to = ?' , user.id) }
 
-  scope :text_search, lambda { |query|
-    query = query.gsub(/[^\w\s\-\.'\p{L}]/u, '').strip
-    where('upper(first_name) LIKE upper(:s) OR upper(last_name) LIKE upper(:s) OR upper(company) LIKE upper(:m) OR upper(email) LIKE upper(:m)', :s => "#{query}%", :m => "%#{query}%")
-  }
+  scope :text_search, lambda { |query| search('first_name_or_last_name_or_company_or_email_cont' => query).result }
 
   uses_user_permissions
   acts_as_commentable
+  uses_comment_extensions
   acts_as_taggable_on :tags
   has_paper_trail :ignore => [ :subscribed_users ]
   has_fields
   exportable
   sortable :by => [ "first_name ASC", "last_name ASC", "company ASC", "rating DESC", "created_at DESC", "updated_at DESC" ], :default => "created_at DESC"
 
+  has_ransackable_associations %w(contact campaign tasks tags activities emails addresses comments)
+  ransack_can_autocomplete
+
   validates_presence_of :first_name, :message => :missing_first_name
   validates_presence_of :last_name, :message => :missing_last_name if Setting.require_last_names
   validate :users_for_shared_access
@@ -91,29 +93,38 @@ class Lead < ActiveRecord::Base
 
   # Default values provided through class methods.
   #----------------------------------------------------------------------------
-  def self.per_page ; 20                  ; end
-  def self.outline  ; "long"              ; end
+  def self.per_page ; 20 ; end
   def self.first_name_position ; "before" ; end
 
   # Save the lead along with its permissions.
   #----------------------------------------------------------------------------
   def save_with_permissions(params)
     self.campaign = Campaign.find(params[:campaign]) unless params[:campaign].blank?
-    if self.access == "Campaign" && self.campaign # Copy campaign permissions.
+    if params[:lead][:access] == "Campaign" && self.campaign # Copy campaign permissions.
       save_with_model_permissions(Campaign.find(self.campaign_id))
     else
-      super(params[:users]) # invoke :save_with_permissions in plugin.
+      self.attributes = params[:leads]
+      save
     end
   end
 
+  # Deprecated: see update_with_lead_counters
+  #----------------------------------------------------------------------------
+  def update_with_permissions(attributes, users = nil)
+    ActiveSupport::Deprecation.warn "lead.update_with_permissions is deprecated and may be removed from future releases, use user_ids and group_ids inside attributes instead and call lead.update_with_lead_counters"
+    update_with_lead_counters(attributes)
+  end
+
   # Update lead attributes taking care of campaign lead counters when necessary.
   #----------------------------------------------------------------------------
-  def update_with_permissions(attributes, users)
+  def update_with_lead_counters(attributes)
     if self.campaign_id == attributes[:campaign_id] # Same campaign (if any).
-      super(attributes, users)                      # See lib/fat_free_crm/permissions.rb
+      self.attributes = attributes
+      self.save
     else                                            # Campaign has been changed -- update lead counters...
       decrement_leads_count                         # ..for the old campaign...
-      lead = super(attributes, users)               # Assign new campaign.
+      self.attributes = attributes                  # Assign new campaign.
+      lead = self.save
       increment_leads_count                         # ...and now for the new campaign.
       lead
     end
@@ -123,8 +134,8 @@ class Lead < ActiveRecord::Base
   # successful promotion Lead status gets set to :converted.
   #----------------------------------------------------------------------------
   def promote(params)
-    account     = Account.create_or_select_for(self, params[:account], params[:users])
-    opportunity = Opportunity.create_for(self, account, params[:opportunity], params[:users])
+    account     = Account.create_or_select_for(self, params[:account])
+    opportunity = Opportunity.create_for(self, account, params[:opportunity])
     contact     = Contact.create_for(self, account, opportunity, params)
 
     [account, opportunity, contact]

data/app/models/entities/opportunity.rb

@@ -53,31 +53,47 @@ class Opportunity < ActiveRecord::Base
   scope :state, lambda { |filters|
     where('stage IN (?)' + (filters.delete('other') ? ' OR stage IS NULL' : ''), filters)
   }
-  scope :created_by, lambda { |user| where('user_id = ?', user.id) }
+  scope :created_by,  lambda { |user| where('user_id = ?', user.id) }
   scope :assigned_to, lambda { |user| where('assigned_to = ?', user.id) }
-  scope :won,      where("opportunities.stage = 'won'")
-  scope :lost,     where("opportunities.stage = 'lost'")
-  scope :pipeline, where("opportunities.stage IS NULL OR (opportunities.stage != 'won' AND opportunities.stage != 'lost')")
+  scope :won,         where("opportunities.stage = 'won'")
+  scope :lost,        where("opportunities.stage = 'lost'")
+  scope :not_lost,    where("opportunities.stage <> 'lost'")
+  scope :pipeline,    where("opportunities.stage IS NULL OR (opportunities.stage != 'won' AND opportunities.stage != 'lost')")
+  scope :unassigned,  where("opportunities.assigned_to IS NULL")
 
   # Search by name OR id
   scope :text_search, lambda { |query|
-    query = query.gsub(/[^\w\s\-\.'\p{L}]/u, '').strip
     # postgresql does not like to compare string to integer field
     if query =~ /^\d+$/
+      query = query.gsub(/[^\w\s\-\.'\p{L}]/u, '').strip
       where('upper(name) LIKE upper(:name) OR opportunities.id = :id', :name => "%#{query}%", :id => query)
     else
-      where('upper(name) LIKE upper(:name)', :name => "%#{query}%")
+      search('name_cont' => query).result
     end
   }
 
+  scope :visible_on_dashboard, lambda { |user|
+    # Show opportunities which either belong to the user and are unassigned, or are assigned to the user and haven't been closed (won/lost)
+    where('(user_id = :user_id AND assigned_to IS NULL) OR assigned_to = :user_id', :user_id => user.id).where("opportunities.stage != 'won'").where("opportunities.stage != 'lost'")
+  }
+
+  scope :by_closes_on, order(:closes_on)
+  scope :by_amount, order('opportunities.amount DESC')
+
   uses_user_permissions
   acts_as_commentable
+  uses_comment_extensions
   acts_as_taggable_on :tags
   has_paper_trail :ignore => [ :subscribed_users ]
   has_fields
   exportable
   sortable :by => [ "name ASC", "amount DESC", "amount*probability DESC", "probability DESC", "closes_on ASC", "created_at DESC", "updated_at DESC" ], :default => "created_at DESC"
 
+  has_ransackable_associations %w(account contacts tags activities emails comments)
+  ransack_can_autocomplete
+
+  validates :stage, :inclusion => { :in => Setting.unroll(:opportunity_stage).map{|s| s.last.to_s } }
+
   validates_presence_of :name, :message => :missing_opportunity_name
   validates_numericality_of [ :probability, :amount, :discount ], :allow_nil => true
   validate :users_for_shared_access
@@ -92,8 +108,7 @@ class Opportunity < ActiveRecord::Base
 
   # Default values provided through class methods.
   #----------------------------------------------------------------------------
-  def self.per_page ; 20     ; end
-  def self.outline  ; "long" ; end
+  def self.per_page ; 20 ; end
 
   #----------------------------------------------------------------------------
   def weighted_amount
@@ -105,12 +120,13 @@ class Opportunity < ActiveRecord::Base
   def save_with_account_and_permissions(params)
     # Quick sanitization, makes sure Account will not search for blank id.
     params[:account].delete(:id) if params[:account][:id].blank?
-    account = Account.create_or_select_for(self, params[:account], params[:users])
+    account = Account.create_or_select_for(self, params[:account])
     self.account_opportunity = AccountOpportunity.new(:account => account, :opportunity => self) unless account.id.blank?
     self.account = account
-    self.contacts << Contact.find(params[:contact]) unless params[:contact].blank?
     self.campaign = Campaign.find(params[:campaign]) unless params[:campaign].blank?
-    self.save_with_permissions(params[:users])
+    result = self.save
+    self.contacts << Contact.find(params[:contact]) unless params[:contact].blank?
+    result
   end
 
   # Backend handler for [Update Opportunity] form (see opportunity/update).
@@ -119,13 +135,16 @@ class Opportunity < ActiveRecord::Base
     if params[:account] && (params[:account][:id] == "" || params[:account][:name] == "")
       self.account = nil # Opportunity is not associated with the account anymore.
     elsif params[:account]
-      account = Account.create_or_select_for(self, params[:account], params[:users])
+      account = Account.create_or_select_for(self, params[:account])
       if self.account != account and account.id.present?
         self.account_opportunity = AccountOpportunity.new(:account => account, :opportunity => self)
       end
     end
     self.reload
-    self.update_with_permissions(params[:opportunity], params[:users])
+    # Must set access before user_ids, because user_ids= method depends on access value.
+    self.access = params[:opportunity][:access] if params[:opportunity][:access]
+    self.attributes = params[:opportunity]
+    self.save
   end
 
   # Attach given attachment to the opportunity if it hasn't been attached already.
@@ -148,7 +167,7 @@ class Opportunity < ActiveRecord::Base
 
   # Class methods.
   #----------------------------------------------------------------------------
-  def self.create_for(model, account, params, users)
+  def self.create_for(model, account, params)
     opportunity = Opportunity.new(params)
 
     # Save the opportunity if its name was specified and account has no errors.
@@ -156,7 +175,7 @@ class Opportunity < ActiveRecord::Base
       # Note: opportunity.account = account doesn't seem to work here.
       opportunity.account_opportunity = AccountOpportunity.new(:account => account, :opportunity => opportunity) unless account.id.blank?
       if opportunity.access != "Lead" || model.nil?
-        opportunity.save_with_permissions(users)
+        opportunity.save
       else
         opportunity.save_with_model_permissions(model)
       end
@@ -186,4 +205,3 @@ class Opportunity < ActiveRecord::Base
   end
 
 end
-

data/app/models/fields/custom_field.rb

@@ -63,8 +63,8 @@ class CustomField < Field
   before_create    :add_column
 
   SAFE_DB_TRANSITIONS = {
-    :any => [[:date, :time, :timestamp], [:integer, :float]],
-    :one => {:string => :text}
+    :any => [['date', 'time', 'timestamp'], ['integer', 'float']],
+    :one => {'string' => 'text'}
   }
 
   def available_as
@@ -73,7 +73,16 @@ class CustomField < Field
     end
   end
 
-protected
+  # Extra validation that is called on this field when validation happens
+  # obj is reference to parent object
+  #------------------------------------------------------------------------------
+  def custom_validator(obj)
+    attr = name.to_sym
+    obj.errors.add(attr, ::I18n.t('activerecord.errors.models.custom_field.required', :field => label)) if required? and obj.send(attr).blank?
+    obj.errors.add(attr, ::I18n.t('activerecord.errors.models.custom_field.maxlength', :field => label)) if (maxlength.to_i > 0) and (obj.send(attr).to_s.length > maxlength.to_i)
+  end
+  
+  protected
 
   # When changing a custom field's type, it may be necessary to
   # change the column type in the database. This method returns
@@ -82,14 +91,15 @@ protected
   #   :null   => no transition needed
   #   :safe   => transition is safe
   #   :unsafe => transition is unsafe
+  #------------------------------------------------------------------------------
   def db_transition_safety(old_type, new_type = self.as)
-    old_col, new_col = [old_type, new_type].map{|t| column_type(t) }
+    old_col, new_col = [old_type, new_type].map{|t| column_type(t).to_s }
     return :null if old_col == new_col  # no transition needed
     return :safe if SAFE_DB_TRANSITIONS[:one].any? do |start, final|
-      old_col == start && new_col == final  # one-to-one
+      old_col == start.to_s && new_col == final.to_s  # one-to-one
     end
     return :safe if SAFE_DB_TRANSITIONS[:any].any? do |col_set|
-      [old_col, new_col].all?{|c| col_set.include?(c)}  # any-to-any
+      [old_col, new_col].all?{|c| col_set.include?(c.to_s)}  # any-to-any
     end
     :unsafe # Else, unsafe.
   end
@@ -102,10 +112,11 @@ protected
     klass.columns.map(&:name)
   end
 
+  # Generate column name for custom field.
+  # If column name is already taken, a numeric suffix is appended.
+  # Example column sequence: cf_custom, cf_custom_2, cf_custom_3, ...
+  #------------------------------------------------------------------------------
   def generate_column_name
-    # Generate column name for custom field.
-    # If column name is already taken, a numeric suffix is appended.
-    # Example column sequence: cf_custom, cf_custom_2, cf_custom_3, ...
     suffix = nil
     field_name = 'cf_' + label.downcase.gsub(/[^a-z0-9]+/, '_')
     while (final_name = [field_name, suffix].compact.join('_')) &&
@@ -116,23 +127,28 @@ protected
   end
 
   # Returns options for ActiveRecord operations
+  #------------------------------------------------------------------------------
   def column_options
-    Field.field_types[self.as][:options] || {}
+    Field.field_types[self.as][:column_options] || {}
   end
 
+  # Create a new column to hold the custom field data
+  #------------------------------------------------------------------------------
   def add_column
     self.name = generate_column_name if name.blank?
     connection.add_column(table_name, name, column_type, column_options)
     klass.reset_column_information
+    klass.serialize_custom_fields!
   end
 
+  # Change database column type only if safe to do so
+  # Note: columns will never be renamed or destroyed
+  #------------------------------------------------------------------------------
   def update_column
-    # Change database column type if appropriate
-    # (NOTE: Columns will never be renamed or destroyed)
     if self.errors.empty? && db_transition_safety(as_was) == :safe
       connection.change_column(table_name, name, column_type, column_options)
       klass.reset_column_information
+      klass.serialize_custom_fields!
     end
   end
 end
-