fat_free_crm 0.18.2 → 0.19.0

data/app/helpers/campaigns_helper.rb

@@ -14,7 +14,7 @@ module CampaignsHelper
 
   #----------------------------------------------------------------------------
   def performance(actual, target)
-    if target.to_i > 0 && actual.to_i > 0
+    if target.to_i.positive? && actual.to_i.positive?
       if target > actual
         n = 100 - actual * 100 / target
         html = content_tag(:span, "(-#{number_to_percentage(n, precision: 1)})", class: "warn")

data/app/helpers/contacts_helper.rb

@@ -12,9 +12,7 @@ module ContactsHelper
     summary = ['']
     summary << contact.title.titleize if contact.title?
     summary << contact.department if contact.department?
-    if contact.account&.name?
-      summary.last += " #{t(:at)} #{contact.account.name}"
-    end
+    summary.last += " #{t(:at)} #{contact.account.name}" if contact.account&.name?
     summary << contact.email if contact.email.present?
     summary << "#{t(:phone_small)}: #{contact.phone}" if contact.phone.present?
     summary << "#{t(:mobile_small)}: #{contact.mobile}" if contact.mobile.present?

data/app/helpers/opportunities_helper.rb

@@ -51,24 +51,16 @@ module OpportunitiesHelper
     msg = []
     won_or_lost = %w[won lost].include?(opportunity.stage)
 
-    if opportunity.weighted_amount != 0
-      msg << content_tag(:b, number_to_currency(opportunity.weighted_amount, precision: 0))
-    end
+    msg << content_tag(:b, number_to_currency(opportunity.weighted_amount, precision: 0)) if opportunity.weighted_amount != 0
 
     unless won_or_lost
       if detailed
-        if opportunity.amount.to_f != 0
-          msg << number_to_currency(opportunity.amount.to_f, precision: 0)
-        end
+        msg << number_to_currency(opportunity.amount.to_f, precision: 0) if opportunity.amount.to_f != 0
 
-        if opportunity.discount.to_f != 0
-          msg << t(:discount) + ' ' + number_to_currency(opportunity.discount, precision: 0)
-        end
+        msg << t(:discount) + ' ' + number_to_currency(opportunity.discount, precision: 0) if opportunity.discount.to_f != 0
       end
 
-      if opportunity.probability.to_i != 0
-        msg << t(:probability) + ' ' + opportunity.probability.to_s + '%'
-      end
+      msg << t(:probability) + ' ' + opportunity.probability.to_s + '%' if opportunity.probability.to_i != 0
     end
 
     msg << opportunity_closes_on_message(opportunity, won_or_lost)

data/app/helpers/tasks_helper.rb

@@ -11,7 +11,7 @@ module TasksHelper
   #----------------------------------------------------------------------------
   def task_filter_checkbox(view, filter, count)
     name = "filter_by_task_#{view}"
-    checked = (session[name] ? session[name].split(",").include?(filter.to_s) : count > 0)
+    checked = (session[name] ? session[name].split(",").include?(filter.to_s) : count.positive?)
     url = url_for(action: :filter, view: view)
     onclick = %{
       $('#loading').show();

data/app/helpers/users_helper.rb

@@ -7,9 +7,7 @@
 #------------------------------------------------------------------------------
 module UsersHelper
   def language_for(user)
-    if user.preference[:locale]
-      _locale, language = languages.detect { |locale, _language| locale == user.preference[:locale] }
-    end
+    _locale, language = languages.detect { |locale, _language| locale == user.preference[:locale] } if user.preference[:locale]
     language || "English"
   end
 

data/{config/initializers/paper_trail.rb → app/mailers/devise_mailer.rb}

@@ -5,4 +5,8 @@
 # Fat Free CRM is freely distributable under the terms of MIT license.
 # See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
 #------------------------------------------------------------------------------
-PaperTrail.config.track_associations = false
+class DeviseMailer < Devise::Mailer
+  def template_paths
+    ["devise/mailer"]
+  end
+end

data/app/mailers/user_mailer.rb

@@ -6,15 +6,6 @@
 # See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
 #------------------------------------------------------------------------------
 class UserMailer < ActionMailer::Base
-  def password_reset_instructions(user)
-    @edit_password_url = edit_password_url(user.perishable_token)
-
-    mail subject: "Fat Free CRM: " + I18n.t(:password_reset_instruction),
-         to: user.email,
-         from: from_address,
-         date: Time.now
-  end
-
   def assigned_entity_notification(entity, assigner)
     @entity_url = url_for(entity)
     @entity_name = entity.name

data/app/models/entities/account.rb

@@ -28,8 +28,8 @@
 #
 
 class Account < ActiveRecord::Base
-  belongs_to :user
-  belongs_to :assignee, class_name: "User", foreign_key: :assigned_to
+  belongs_to :user, optional: true # TODO: Is this really optional?
+  belongs_to :assignee, class_name: "User", foreign_key: :assigned_to, optional: true
   has_many :account_contacts, dependent: :destroy
   has_many :contacts, -> { distinct }, through: :account_contacts
   has_many :account_opportunities, dependent: :destroy
@@ -46,7 +46,7 @@ class Account < ActiveRecord::Base
   accepts_nested_attributes_for :billing_address,  allow_destroy: true, reject_if: proc { |attributes| Address.reject_address(attributes) }
   accepts_nested_attributes_for :shipping_address, allow_destroy: true, reject_if: proc { |attributes| Address.reject_address(attributes) }
 
-  scope :state, ->(filters) {
+  scope :state, lambda { |filters|
     where('category IN (?)' + (filters.delete('other') ? ' OR category IS NULL' : ''), filters)
   }
   scope :created_by,  ->(user) { where(user_id: user.id) }
@@ -54,7 +54,7 @@ class Account < ActiveRecord::Base
 
   scope :text_search, ->(query) { ransack('name_or_email_cont' => query).result }
 
-  scope :visible_on_dashboard, ->(user) {
+  scope :visible_on_dashboard, lambda { |user|
     # Show accounts which either belong to the user and are unassigned, or are assigned to the user
     where('(user_id = :user_id AND assigned_to IS NULL) OR assigned_to = :user_id', user_id: user.id)
   }
@@ -91,6 +91,7 @@ class Account < ActiveRecord::Base
   #----------------------------------------------------------------------------
   def location
     return "" unless self[:billing_address]
+
     location = self[:billing_address].strip.split("\n").last
     location&.gsub(/(^|\s+)\d+(:?\s+|$)/, " ")&.strip
   end
@@ -98,9 +99,7 @@ class Account < ActiveRecord::Base
   # Attach given attachment to the account if it hasn't been attached already.
   #----------------------------------------------------------------------------
   def attach!(attachment)
-    unless send("#{attachment.class.name.downcase}_ids").include?(attachment.id)
-      send(attachment.class.name.tableize) << attachment
-    end
+    send(attachment.class.name.tableize) << attachment unless send("#{attachment.class.name.downcase}_ids").include?(attachment.id)
   end
 
   # Discard given attachment from the account.
@@ -117,14 +116,15 @@ class Account < ActiveRecord::Base
   #----------------------------------------------------------------------------
   def self.create_or_select_for(model, params)
     # Attempt to find existing account
-    if params[:id].present?
-      return Account.find(params[:id])
-    elsif params[:name].present?
+    return Account.find(params[:id]) if params[:id].present?
+
+    if params[:name].present?
       account = Account.find_by(name: params[:name])
       return account if account
     end
 
     # Fallback to create new account
+    params[:user] = model.user if model
     account = Account.new(params)
     if account.access != "Lead" || model.nil?
       account.save

data/app/models/entities/campaign.rb

@@ -32,8 +32,8 @@
 #
 
 class Campaign < ActiveRecord::Base
-  belongs_to :user
-  belongs_to :assignee, class_name: "User", foreign_key: :assigned_to
+  belongs_to :user, optional: true # TODO: Is this really optional?
+  belongs_to :assignee, class_name: "User", foreign_key: :assigned_to, optional: true # TODO: Is this really optional?
   has_many :tasks, as: :asset, dependent: :destroy # , :order => 'created_at DESC'
   has_many :leads, -> { order "id DESC" }, dependent: :destroy
   has_many :opportunities, -> { order "id DESC" }, dependent: :destroy
@@ -41,7 +41,7 @@ class Campaign < ActiveRecord::Base
 
   serialize :subscribed_users, Set
 
-  scope :state, ->(filters) {
+  scope :state, lambda { |filters|
     where('status IN (?)' + (filters.delete('other') ? ' OR status IS NULL' : ''), filters)
   }
   scope :created_by,  ->(user) { where(user_id: user.id) }
@@ -103,9 +103,7 @@ class Campaign < ActiveRecord::Base
   # Make sure end date > start date.
   #----------------------------------------------------------------------------
   def start_and_end_dates
-    if (starts_on && ends_on) && (starts_on > ends_on)
-      errors.add(:ends_on, :dates_not_in_sequence)
-    end
+    errors.add(:ends_on, :dates_not_in_sequence) if (starts_on && ends_on) && (starts_on > ends_on)
   end
 
   # Make sure at least one user has been selected if the campaign is being shared.

data/app/models/entities/contact.rb

@@ -40,9 +40,9 @@
 
 class Contact < ActiveRecord::Base
   belongs_to :user
-  belongs_to :lead
-  belongs_to :assignee, class_name: "User", foreign_key: :assigned_to
-  belongs_to :reporting_user, class_name: "User", foreign_key: :reports_to
+  belongs_to :lead, optional: true # TODO: Is this really optional?
+  belongs_to :assignee, class_name: "User", foreign_key: :assigned_to, optional: true # TODO: Is this really optional?
+  belongs_to :reporting_user, class_name: "User", foreign_key: :reports_to, optional: true # TODO: Is this really optional?
   has_one :account_contact, dependent: :destroy
   has_one :account, through: :account_contact
   has_many :contact_opportunities, dependent: :destroy
@@ -64,7 +64,7 @@ class Contact < ActiveRecord::Base
   scope :created_by,  ->(user) { where(user_id: user.id) }
   scope :assigned_to, ->(user) { where(assigned_to: user.id) }
 
-  scope :text_search, ->(query) {
+  scope :text_search, lambda { |query|
     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.
@@ -98,6 +98,21 @@ class Contact < ActiveRecord::Base
   validates_presence_of :last_name,  message: :missing_last_name,  if: -> { Setting.require_last_names  }
   validate :users_for_shared_access
 
+  validates_length_of :first_name, maximum: 64
+  validates_length_of :last_name, maximum: 64
+  validates_length_of :title, maximum: 64
+  validates_length_of :department, maximum: 64
+  validates_length_of :email, maximum: 254
+  validates_length_of :alt_email, maximum: 254
+  validates_length_of :phone, maximum: 32
+  validates_length_of :mobile, maximum: 32
+  validates_length_of :fax, maximum: 32
+  validates_length_of :blog, maximum: 128
+  validates_length_of :linkedin, maximum: 128
+  validates_length_of :facebook, maximum: 128
+  validates_length_of :twitter, maximum: 128
+  validates_length_of :skype, maximum: 128
+
   # Default values provided through class methods.
   #----------------------------------------------------------------------------
   def self.per_page
@@ -140,9 +155,7 @@ class Contact < ActiveRecord::Base
   # Attach given attachment to the contact if it hasn't been attached already.
   #----------------------------------------------------------------------------
   def attach!(attachment)
-    unless send("#{attachment.class.name.downcase}_ids").include?(attachment.id)
-      send(attachment.class.name.tableize) << attachment
-    end
+    send(attachment.class.name.tableize) << attachment unless send("#{attachment.class.name.downcase}_ids").include?(attachment.id)
   end
 
   # Discard given attachment from the contact.
@@ -160,7 +173,7 @@ class Contact < ActiveRecord::Base
   def self.create_for(model, account, opportunity, params)
     attributes = {
       lead_id:     model.id,
-      user_id:     params[:account][:user_id],
+      user_id:     params[:account][:user_id] || account.user_id,
       assigned_to: params[:account][:assigned_to],
       access:      params[:access]
     }
@@ -173,9 +186,7 @@ class Contact < ActiveRecord::Base
     # 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
+        contact.send "#{field.name}=", model.send(field.name) if contact.respond_to?(field.name)
       end
     end
 
@@ -207,7 +218,8 @@ class Contact < ActiveRecord::Base
   #----------------------------------------------------------------------------
   def save_account(params)
     account_params = params[:account]
-    self.account = if account_params && account_params[:id] != "" && account_params[:name] != ""
+    valid_account = account_params && (account_params[:id].present? || account_params[:name].present?)
+    self.account = if valid_account
                      Account.create_or_select_for(self, account_params)
                    else
                      nil

data/app/models/entities/lead.rb

@@ -39,9 +39,9 @@
 #
 
 class Lead < ActiveRecord::Base
-  belongs_to :user
-  belongs_to :campaign
-  belongs_to :assignee, class_name: "User", foreign_key: :assigned_to
+  belongs_to :user, optional: true # TODO: Is this really optional?
+  belongs_to :campaign, optional: true # TODO: Is this really optional?
+  belongs_to :assignee, class_name: "User", foreign_key: :assigned_to, optional: true # TODO: Is this really optional?
   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, -> { where "address_type='Business'" }, dependent: :destroy, as: :addressable, class_name: "Address"
@@ -50,9 +50,9 @@ class Lead < ActiveRecord::Base
 
   serialize :subscribed_users, Set
 
-  accepts_nested_attributes_for :business_address, allow_destroy: true
+  accepts_nested_attributes_for :business_address, allow_destroy: true, reject_if: proc { |attributes| Address.reject_address(attributes) }
 
-  scope :state, ->(filters) {
+  scope :state, lambda { |filters|
     where(['status IN (?)' + (filters.delete('other') ? ' OR status IS NULL' : ''), filters])
   }
   scope :converted,    ->       { where(status: 'converted') }
@@ -123,8 +123,8 @@ class Lead < ActiveRecord::Base
   # successful promotion Lead status gets set to :converted.
   #----------------------------------------------------------------------------
   def promote(params)
-    account_params = params[:account] ? params[:account] : {}
-    opportunity_params = params[:opportunity] ? params[:opportunity] : {}
+    account_params = params[:account] || {}
+    opportunity_params = params[:opportunity] || {}
 
     account     = Account.create_or_select_for(self, account_params)
     opportunity = Opportunity.create_for(self, account, opportunity_params)

data/app/models/entities/opportunity.rb

@@ -28,9 +28,9 @@
 #
 
 class Opportunity < ActiveRecord::Base
-  belongs_to :user
-  belongs_to :campaign
-  belongs_to :assignee, class_name: "User", foreign_key: :assigned_to
+  belongs_to :user, optional: true
+  belongs_to :campaign, optional: true
+  belongs_to :assignee, class_name: "User", foreign_key: :assigned_to, optional: true
   has_one :account_opportunity, dependent: :destroy
   has_one :account, through: :account_opportunity
   has_many :contact_opportunities, dependent: :destroy
@@ -40,7 +40,7 @@ class Opportunity < ActiveRecord::Base
 
   serialize :subscribed_users, Set
 
-  scope :state, ->(filters) {
+  scope :state, lambda { |filters|
     where('stage IN (?)' + (filters.delete('other') ? ' OR stage IS NULL' : ''), filters)
   }
   scope :created_by,  ->(user) { where('user_id = ?', user.id) }
@@ -53,7 +53,7 @@ class Opportunity < ActiveRecord::Base
   scope :weighted_sort, -> { select('*, amount*probability') }
 
   # Search by name OR id
-  scope :text_search, ->(query) {
+  scope :text_search, lambda { |query|
     if query.match?(/\A\d+\z/)
       where('upper(name) LIKE upper(:name) OR opportunities.id = :id', name: "%#{query}%", id: query)
     else
@@ -61,7 +61,7 @@ class Opportunity < ActiveRecord::Base
     end
   }
 
-  scope :visible_on_dashboard, ->(user) {
+  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'")
   }
@@ -135,9 +135,7 @@ class Opportunity < ActiveRecord::Base
   # Attach given attachment to the opportunity if it hasn't been attached already.
   #----------------------------------------------------------------------------
   def attach!(attachment)
-    unless send("#{attachment.class.name.downcase}_ids").include?(attachment.id)
-      send(attachment.class.name.tableize) << attachment
-    end
+    send(attachment.class.name.tableize) << attachment unless send("#{attachment.class.name.downcase}_ids").include?(attachment.id)
   end
 
   # Discard given attachment from the opportunity.

data/app/models/fields/custom_field.rb

@@ -96,6 +96,7 @@ class CustomField < Field
     return :safe if SAFE_DB_TRANSITIONS[:any].any? do |col_set|
       [old_col, new_col].all? { |c| col_set.include?(c.to_s) } # any-to-any
     end
+
     :unsafe # Else, unsafe.
   end
 

data/app/models/fields/custom_field_date_pair.rb

@@ -11,6 +11,7 @@ class CustomFieldDatePair < CustomFieldPair
   #------------------------------------------------------------------------------
   def render_value(object)
     return "" unless paired_with.present?
+
     from = render(object.send(name))
     to = render(object.send(paired_with.name))
     if from.present? && to.present?
@@ -34,6 +35,7 @@ class CustomFieldDatePair < CustomFieldPair
     if pair_id.present?
       start = CustomFieldPair.find(pair_id)
       return if start.nil?
+
       from = obj.send(start.name)
       to = obj.send(name)
       obj.errors.add(name.to_sym, ::I18n.t('activerecord.errors.models.custom_field.endbeforestart', field: start.label)) if from.present? && to.present? && (from > to)

data/app/models/fields/field.rb

@@ -34,7 +34,7 @@ class Field < ActiveRecord::Base
   serialize :collection, Array
   serialize :settings, HashWithIndifferentAccess
 
-  belongs_to :field_group
+  belongs_to :field_group, optional: true # TODO: Is this really optional?
 
   scope :core_fields,   -> { where(type: 'CoreField') }
   scope :custom_fields, -> { where("type != 'CoreField'") }
@@ -105,8 +105,6 @@ class Field < ActiveRecord::Base
     end
   end
 
-  protected
-
   class << self
     # Provides access to registered field_types
     #------------------------------------------------------------------------------

data/app/models/list.rb

@@ -12,7 +12,7 @@ class List < ActiveRecord::Base
 
   # Parses the controller from the url
   def controller
-    (url || "").sub(/\A\//, '').split(/\/|\?/).first
+    (url || "").sub(%r{\A/}, '').split(%r{/|\?}).first
   end
 
   ActiveSupport.run_load_hooks(:fat_free_crm_list, self)

data/app/models/observers/entity_observer.rb

@@ -13,17 +13,13 @@ class EntityObserver < ActiveRecord::Observer
   end
 
   def after_update(item)
-    if item.saved_change_to_assigned_to? && item.assignee != current_user
-      send_notification_to_assignee(item)
-    end
+    send_notification_to_assignee(item) if item.saved_change_to_assigned_to? && item.assignee != current_user
   end
 
   private
 
   def send_notification_to_assignee(item)
-    if item.assignee.present? && current_user.present? && can_send_email?
-      UserMailer.assigned_entity_notification(item, current_user).deliver_now
-    end
+    UserMailer.assigned_entity_notification(item, current_user).deliver_now if item.assignee.present? && current_user.present? && can_send_email?
   end
 
   # Need to have a host set before email can be sent
@@ -33,7 +29,7 @@ class EntityObserver < ActiveRecord::Observer
 
   def current_user
     # this deals with whodunnit inconsistencies, where in some cases it's set to a user's id and others the user object itself
-    user_id_or_user = PaperTrail.whodunnit
+    user_id_or_user = PaperTrail.request.whodunnit
     if user_id_or_user.is_a?(User)
       user_id_or_user
     elsif user_id_or_user.is_a?(String)