fat_free_crm 0.12.3 → 0.13.0

data/app/helpers/admin/application_helper.rb

@@ -9,9 +9,7 @@ module Admin::ApplicationHelper
     link_to(t(:yes_button),
       url_for([:admin, model]),
       :method  => :delete,
-      :remote  => true,
-      :onclick => visual_effect(:highlight, dom_id(model), :startcolor => "#ffe4e1")
+      :remote  => true
     )
   end
 end
-

data/app/helpers/admin/field_groups_helper.rb

@@ -4,6 +4,7 @@
 # See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
 #------------------------------------------------------------------------------
 module Admin::FieldGroupsHelper
+
   def field_group_subtitle(field_group)
     asset = field_group.klass_name.downcase
     html = t(field_group.name, :default => field_group.label)
@@ -16,7 +17,7 @@ module Admin::FieldGroupsHelper
     end
     html.html_safe
   end
-  
+
   def link_to_confirm(field_group)
     link_to(t(:delete) + "?", confirm_admin_field_group_path(field_group), :method => :get, :remote => true)
   end

data/app/helpers/application_helper.rb

@@ -109,7 +109,7 @@ module ApplicationHelper
     link_to(t(:edit),
       options[:url] || polymorphic_url(record, :action => :edit),
       :remote  => true,
-      :onclick => "this.href = this.href.split('?')[0] + '?previous='+crm.find_form('edit_#{name}');"
+      :onclick => "this.href = this.href.split('?')[0] + '?previous='+crm.find_form('edit_#{name}');".html_safe
     )
   end
 
@@ -122,7 +122,6 @@ module ApplicationHelper
       options[:url] || url_for(record),
       :method => :delete,
       :remote => true,
-      :onclick => visual_effect(:highlight, dom_id(object), :startcolor => "#ffe4e1"),
       :confirm => confirm
     )
   end
@@ -135,8 +134,7 @@ module ApplicationHelper
     link_to(t(:discard),
       url_for(:controller => parent, :action => :discard, :id => parent_id, :attachment => object.class.name, :attachment_id => object.id),
       :method  => :post,
-      :remote  => true,
-      :onclick => visual_effect(:highlight, dom_id(object), :startcolor => "#ffe4e1")
+      :remote  => true
     )
   end
 
@@ -197,8 +195,8 @@ module ApplicationHelper
   def visible;   { :style => "visibility:visible;" }; end
 
   #----------------------------------------------------------------------------
-  def one_submit_only(form)
-    { :onsubmit => "$$('#'+this.id+' input[type=\"submit\"]')[0].disabled = true" }
+  def one_submit_only(form='')
+    { :onsubmit => "jQuery('#'+this.id+' input[type=\\'submit\\']').disable()".html_safe }
   end
 
   #----------------------------------------------------------------------------
@@ -215,11 +213,10 @@ module ApplicationHelper
   def confirm_delete(model, params = {})
     question = %(<span class="warn">#{t(:confirm_delete, model.class.to_s.downcase)}</span>).html_safe
     yes = link_to(t(:yes_button), params[:url] || model, :method => :delete)
-    no = link_to_function(t(:no_button), "$('menu').update($('confirm').innerHTML)")
-    update_page do |page|
-      page << "$('confirm').update($('menu').innerHTML)"
-      page[:menu].replace_html "#{question} #{yes} : #{no}"
-    end
+    no = link_to_function(t(:no_button), "jQuery('#menu').html(jQuery('#confirm').html());")
+    text = "jQuery('#confirm').html( jQuery('#menu').html() );\n"
+    text << "jQuery('#menu').html('#{question} #{yes} : #{no}');"
+    text.html_safe
   end
 
   #----------------------------------------------------------------------------
@@ -236,10 +233,10 @@ module ApplicationHelper
   # Refresh sidebar using the action view within an arbitrary controller.
   #----------------------------------------------------------------------------
   def refresh_sidebar_for(view, action = nil, shake = nil)
-    update_page do |page|
-      page[:sidebar].replace_html :partial => "layouts/sidebar", :locals => { :view => view, :action => action }
-      page[shake].visual_effect(:shake, :duration => 0.2, :distance => 3) if shake
-    end
+    text = ""
+    text << "jQuery('#sidebar').html('#{ j render(:partial => "layouts/sidebar", :locals => { :view => view, :action => action }) }');"
+    text << "jQuery('##{j shake.to_s}').effect('shake', { duration:200, distance: 3 });" if shake
+    text.html_safe
   end
 
   # Display web presence mini-icons for Contact or Lead.
@@ -466,11 +463,35 @@ module ApplicationHelper
         content_tag(:li) do
           url = (action == "index") ? send("redraw_#{controller}_path") : send("#{controller.singularize}_path")
           link_to('#', :title => t(view.name, :default => view.title), :"data-view" => view.name, :"data-url" => url, :"data-context" => action, :class => classes) do
-            image_tag(view.icon || 'brief.png')
+            icon = view.icon || 'fa-bars'
+            content_tag(:i, nil, class: "fa #{icon}")
           end
         end
       end.join('').html_safe
     end
   end
 
+  #----------------------------------------------------------------------------
+  # Generate the html for jQuery.timeago function
+  # <span class="timeago" datetime="2008-07-17T09:24:17Z">July 17, 2008</span>
+  def timeago(time, options = {})
+    options[:class] ||= "timeago"
+    content_tag(:span, time.to_s, options.merge( title: time.getutc.iso8601)) if time
+  end
+
+  #----------------------------------------------------------------------------
+  # Translate List name to FontAwesome icon text
+  def get_icon(name)
+    case name
+      when "tasks" then "fa-check-square-o"
+      when "campaigns" then "fa-bar-chart-o"
+      when "leads" then "fa-tasks"
+      when "accounts" then "fa-users"
+      when "contacts" then "fa-user"
+      when "opportunities" then "fa-money"
+      when "team" then "fa-globe"
+    end
+  end
+
+
 end

data/app/helpers/home_helper.rb

@@ -39,7 +39,7 @@ module HomeHelper
   # Activity title for RSS/ATOM feeds.
   #----------------------------------------------------------------------------
   def activity_title(activity)
-    user    = activity.user.full_name
+    user    = activity.user.try(:full_name) || ''
     action  = t('action_' + activity.event)
     type    = t('subject_' + activity.item_type.downcase)
     subject = if item = activity.item
@@ -64,4 +64,3 @@ module HomeHelper
     end
   end
 end
-

data/app/helpers/leads_helper.rb

@@ -29,13 +29,12 @@ module LeadsHelper
 
   #----------------------------------------------------------------------------
   def confirm_reject(lead)
-    question = %(<span class="warn">#{t(:reject_lead_confirm)}</span>).html_safe
+    question = %(<span class="warn">#{t(:reject_lead_confirm)}</span>)
     yes = link_to(t(:yes_button), reject_lead_path(lead), :method => :put)
-    no = link_to_function(t(:no_button), "$('menu').update($('confirm').innerHTML)")
-    update_page do |page|
-      page << "$('confirm').update($('menu').innerHTML)"
-      page[:menu].replace_html "#{question} #{yes} : #{no}"
-    end
+    no = link_to_function(t(:no_button), "jQuery('#menu').html(jQuery('#confirm').html());")
+    text = "jQuery('#confirm').html( jQuery('#menu').html() );\n"
+    text << "jQuery('#menu').html('#{question} #{yes} : #{no}');"
+    text.html_safe
   end
 
   # Sidebar checkbox control for filtering leads by status.

data/app/helpers/tasks_helper.rb

@@ -17,7 +17,7 @@ module TasksHelper
       :loading  => "$('loading').show()",
       :complete => "$('loading').hide()"
     )
-    check_box_tag("filters[]", filter, checked, :onclick => onclick)
+    check_box_tag("filters[]", filter, checked, :onclick => onclick, :id => "filters_#{filter.to_s.underscore}")
   end
 
   #----------------------------------------------------------------------------
@@ -33,21 +33,14 @@ module TasksHelper
 
   #----------------------------------------------------------------------------
   def link_to_task_edit(task, bucket)
-    link_to(t(:edit), edit_task_path(task),
-      :method => :get,
-      :with   => "{ bucket: '#{bucket}', view: '#{@view}', previous: crm.find_form('edit_task') }",
-      :remote => true
-    )
+    link_to(t(:edit), edit_task_path(task, :bucket => bucket, :view => @view, :previous => "crm.find_form('edit_task')"),
+      :method => :get, :remote => true)
   end
 
   #----------------------------------------------------------------------------
   def link_to_task_delete(task, bucket)
-    link_to(t(:delete) + "!", task_path(task),
-      :method => :delete,
-      :with   => "{ bucket: '#{bucket}', view: '#{@view}' }",
-      :before => visual_effect(:highlight, dom_id(task), :startcolor => "#ffe4e1"),
-      :remote => true
-    )
+    link_to(t(:delete) + "!", task_path(task, :bucket => bucket, :view => @view),
+      :method => :delete, :remote => true)
   end
 
   #----------------------------------------------------------------------------
@@ -85,64 +78,57 @@ module TasksHelper
   end
 
   #----------------------------------------------------------------------------
-  def hide_task_and_possibly_bucket(id, bucket)
-    update_page do |page|
-      page[id].replace ""
-
-      if Task.bucket_empty?(bucket, current_user, @view)
-        page["list_#{bucket}"].visual_effect :fade, :duration => 0.5
-      end
-    end
+  def hide_task_and_possibly_bucket(task, bucket)
+    text = "jQuery('##{dom_id(task)}').remove();\n"
+    text << "jQuery('#list_#{h bucket.to_s}').fadeOut({ duration:500 });\n" if Task.bucket_empty?(bucket, current_user, @view)
+    text.html_safe
   end
 
   #----------------------------------------------------------------------------
   def replace_content(task, bucket = nil)
     partial = (task.assigned_to && task.assigned_to != current_user.id) ? "assigned" : "pending"
-    update_page do |page|
-      page[dom_id(task)].replace_html :partial => "tasks/#{partial}", :collection => [ task ], :locals => { :bucket => bucket }
-    end
+    html = render(:partial => "tasks/#{partial}", :collection => [ task ], :locals => { :bucket => bucket })
+    text = "jQuery('##{dom_id(task)}').html('#{ j html }');\n".html_safe
   end
 
   #----------------------------------------------------------------------------
   def insert_content(task, bucket, view)
-    update_page do |page|
-      page["list_#{bucket}"].show
-      page.insert_html :top, bucket, :partial => view, :collection => [ task ], :locals => { :bucket => bucket }
-      page[dom_id(task)].visual_effect :highlight, :duration => 1.5
-    end
+    text = "jQuery('#list_#{bucket}').show();\n".html_safe
+    html = render(:partial => view, :collection => [ task ], :locals => { :bucket => bucket })
+    text << "jQuery('##{h bucket.to_s}').prepend('#{ j html }');\n".html_safe
+    text << "jQuery('##{dom_id(task)}').effect('highlight', { duration:1500 });\n".html_safe
+    text
   end
 
   #----------------------------------------------------------------------------
   def tasks_flash(message)
-    update_page do |page|
-      page[:flash].replace_html message
-      page.call "crm.flash", :notice, true
-    end
+    text = "jQuery('#flash').html('#{ message }');\n"
+    text << "crm.flash('notice', true)\n"
+    text.html_safe
   end
 
   #----------------------------------------------------------------------------
-  def reassign(id)
-    update_page do |page|
-      if @view == "pending" && @task.assigned_to != current_user.id
-        page << hide_task_and_possibly_bucket(id, @task_before_update.bucket)
-        page << tasks_flash("#{t(:task_assigned, @task.assignee.full_name)} (" << link_to(t(:view_assigned_tasks), url_for(:controller => :tasks, :view => :assigned)) << ").")
-      elsif @view == "assigned" && @task.assigned_to.blank?
-        page << hide_task_and_possibly_bucket(id, @task_before_update.bucket)
-        page << tasks_flash("#{t(:task_pending)} (" << link_to(t(:view_pending_tasks), tasks_url) << ").")
-      else
-        page << replace_content(@task, @task.bucket)
-      end
-      page << refresh_sidebar(:index, :filters)
+  def reassign(task)
+    text = "".html_safe
+    if @view == "pending" && @task.assigned_to.present? && @task.assigned_to != current_user.id
+      text << hide_task_and_possibly_bucket(task, @task_before_update.bucket)
+      text << tasks_flash( t(:task_assigned, (h @task.assignee.try(:full_name))) + " (#{link_to(t(:view_assigned_tasks), url_for(:controller => :tasks, :view => :assigned))})" )
+    elsif @view == "assigned" && @task.assigned_to.blank?
+      text << hide_task_and_possibly_bucket(task, @task_before_update.bucket)
+      text << tasks_flash( t(:task_pending) + " (#{link_to(t(:view_pending_tasks), tasks_url)}.")
+    else
+      text << replace_content(@task, @task.bucket)
     end
+    text << refresh_sidebar(:index, :filters)
+    text
   end
 
   #----------------------------------------------------------------------------
-  def reschedule(id)
-    update_page do |page|
-      page << hide_task_and_possibly_bucket(id, @task_before_update.bucket)
-      page << insert_content(@task, @task.bucket, @view)
-      page << refresh_sidebar(:index, :filters)
-    end
+  def reschedule(task)
+    text = hide_task_and_possibly_bucket(task, @task_before_update.bucket)
+    text << insert_content(task, task.bucket, @view)
+    text << refresh_sidebar(:index, :filters)
+    text
   end
 
 end

data/app/models/entities/account.rb

@@ -43,20 +43,20 @@ 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, lambda { |filters|
+  scope :state, ->(filters) {
     where('category IN (?)' + (filters.delete('other') ? ' OR category IS NULL' : ''), filters)
   }
-  scope :created_by, lambda { |user| where(:user_id => user.id) }
-  scope :assigned_to, lambda { |user| where(:assigned_to => user.id) }
+  scope :created_by,  ->(user) { where(:user_id => user.id) }
+  scope :assigned_to, ->(user) { where(:assigned_to => user.id) }
 
-  scope :text_search, lambda { |query| search('name_or_email_cont' => query).result }
+  scope :text_search, ->(query) { search('name_or_email_cont' => query).result }
 
-  scope :visible_on_dashboard, lambda { |user|
+  scope :visible_on_dashboard, ->(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)
   }
 
-  scope :by_name, order(:name)
+  scope :by_name, -> { order(:name) }
 
   uses_user_permissions
   acts_as_commentable
@@ -71,8 +71,11 @@ class Account < ActiveRecord::Base
   ransack_can_autocomplete
 
   validates_presence_of :name, :message => :missing_account_name
-  validates_uniqueness_of :name, :scope => :deleted_at if Setting.require_unique_account_names
+  validates_uniqueness_of :name, :scope => :deleted_at, :if => -> { Setting.require_unique_account_names }
+  validates :rating, :inclusion => { in: 0..5 }, allow_blank: true
+  validates :category, :inclusion => { in: Proc.new{ Setting.unroll(:account_category).map{|s| s.last.to_s} } }, allow_blank: true
   validate :users_for_shared_access
+
   before_save :nullify_blank_category
 
   # Default values provided through class methods.

data/app/models/entities/campaign.rb

@@ -39,13 +39,13 @@ class Campaign < ActiveRecord::Base
 
   serialize :subscribed_users, Set
 
-  scope :state, lambda { |filters|
+  scope :state, ->(filters) {
     where('status IN (?)' + (filters.delete('other') ? ' OR status IS NULL' : ''), filters)
   }
-  scope :created_by, lambda { |user| where('user_id = ?' , user.id) }
-  scope :assigned_to, lambda { |user| where('assigned_to = ?', user.id) }
+  scope :created_by,  ->(user) { where('user_id = ?' , user.id) }
+  scope :assigned_to, ->(user) { where('assigned_to = ?', user.id) }
 
-  scope :text_search, lambda { |query| search('name_cont' => query).result }
+  scope :text_search, ->(query) { search('name_cont' => query).result }
 
   uses_user_permissions
   acts_as_commentable

data/app/models/entities/contact.rb

@@ -40,6 +40,7 @@ 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
   has_one     :account_contact, :dependent => :destroy
   has_one     :account, :through => :account_contact
   has_many    :contact_opportunities, :dependent => :destroy
@@ -49,6 +50,8 @@ class Contact < ActiveRecord::Base
   has_many    :addresses, :dependent => :destroy, :as => :addressable, :class_name => "Address" # advanced search uses this
   has_many    :emails, :as => :mediator
 
+  delegate :campaign, :to => :lead, :allow_nil => true
+
   has_ransackable_associations %w(account opportunities tags activities emails addresses comments tasks)
   ransack_can_autocomplete
 
@@ -56,10 +59,10 @@ class Contact < ActiveRecord::Base
 
   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 :created_by,  ->(user) { where("user_id = ?", user.id) }
+  scope :assigned_to, ->(user) { where("assigned_to = ?", user.id) }
 
-  scope :text_search, lambda { |query|
+  scope :text_search, ->(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.
@@ -89,8 +92,8 @@ class Contact < ActiveRecord::Base
   exportable
   sortable :by => [ "first_name ASC",  "last_name ASC", "created_at DESC", "updated_at DESC" ], :default => "created_at DESC"
 
-  validates_presence_of :first_name, :message => :missing_first_name if Setting.require_first_names
-  validates_presence_of :last_name, :message => :missing_last_name if Setting.require_last_names
+  validates_presence_of :first_name, :message => :missing_first_name, :if => -> { Setting.require_first_names }
+  validates_presence_of :last_name,  :message => :missing_last_name,  :if => -> { Setting.require_last_names  }
   validate :users_for_shared_access
 
   # Default values provided through class methods.

data/app/models/entities/lead.rb

@@ -50,15 +50,15 @@ class Lead < ActiveRecord::Base
 
   accepts_nested_attributes_for :business_address, :allow_destroy => true
 
-  scope :state, lambda { |filters|
+  scope :state, ->(filters) {
     where([ 'status IN (?)' + (filters.delete('other') ? ' OR status IS NULL' : ''), filters ])
   }
-  scope :converted, where(:status => 'converted')
-  scope :for_campaign, lambda { |id| where('campaign_id = ?', id) }
-  scope :created_by, lambda { |user| where('user_id = ?' , user.id) }
-  scope :assigned_to, lambda { |user| where('assigned_to = ?' , user.id) }
+  scope :converted, -> { where(:status => 'converted') }
+  scope :for_campaign, ->(id) { where('campaign_id = ?', id) }
+  scope :created_by, ->(user) { where('user_id = ?' , user.id) }
+  scope :assigned_to, ->(user) { where('assigned_to = ?' , user.id) }
 
-  scope :text_search, lambda { |query| search('first_name_or_last_name_or_company_or_email_cont' => query).result }
+  scope :text_search, ->(query) { search('first_name_or_last_name_or_company_or_email_cont' => query).result }
 
   uses_user_permissions
   acts_as_commentable
@@ -72,8 +72,8 @@ class Lead < ActiveRecord::Base
   has_ransackable_associations %w(contact campaign tasks tags activities emails addresses comments)
   ransack_can_autocomplete
 
-  validates_presence_of :first_name, :message => :missing_first_name if Setting.require_first_names
-  validates_presence_of :last_name, :message => :missing_last_name if Setting.require_last_names
+  validates_presence_of :first_name, :message => :missing_first_name, :if => -> { Setting.require_first_names }
+  validates_presence_of :last_name,  :message => :missing_last_name,  :if => -> { Setting.require_last_names  }
   validate :users_for_shared_access
 
   after_create  :increment_leads_count

data/app/models/entities/opportunity.rb

@@ -38,19 +38,19 @@ class Opportunity < ActiveRecord::Base
 
   serialize :subscribed_users, Set
 
-  scope :state, lambda { |filters|
+  scope :state, ->(filters) {
     where('stage IN (?)' + (filters.delete('other') ? ' OR stage IS NULL' : ''), filters)
   }
-  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 :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")
+  scope :created_by,  ->(user) { where('user_id = ?', user.id) }
+  scope :assigned_to, ->(user) { where('assigned_to = ?', user.id) }
+  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|
+  scope :text_search, ->(query) {
     # postgresql does not like to compare string to integer field
     if query =~ /^\d+$/
       query = query.gsub(/[^\w\s\-\.'\p{L}]/u, '').strip
@@ -60,13 +60,13 @@ class Opportunity < ActiveRecord::Base
     end
   }
 
-  scope :visible_on_dashboard, lambda { |user|
+  scope :visible_on_dashboard, ->(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')
+  scope :by_closes_on, -> { order(:closes_on) }
+  scope :by_amount,    -> { order('opportunities.amount DESC') }
 
   uses_user_permissions
   acts_as_commentable
@@ -80,17 +80,12 @@ class Opportunity < ActiveRecord::Base
   has_ransackable_associations %w(account contacts tags campaign activities emails comments)
   ransack_can_autocomplete
 
-  validates :stage, :inclusion => { :in => Setting.unroll(:opportunity_stage).map{|s| s.last.to_s } }
+  validates :stage, :inclusion => { :in => Proc.new { 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
 
-  # Validate presence of account_opportunity unless the opportunity is deleted [with has_paper_trail],
-  # in which case the account_opportunity will still exist but will be in a deleted state.
-  # validates :account_opportunity, :presence => true, :unless => Proc.new { |o| o.destroyed? }
-  # TODO: Mike, what do you think about the above validation?
-
   after_create  :increment_opportunities_count
   after_destroy :decrement_opportunities_count