fat_free_crm 0.11.3 → 0.11.4

data/app/controllers/entities_controller.rb

@@ -18,12 +18,16 @@
 class EntitiesController < ApplicationController
   before_filter :require_user
   before_filter :set_current_tab, :only => [ :index, :show ]
+  before_filter :set_view, :only => [ :index, :show, :redraw ]
+  
+  before_filter :set_options, :only => :index
+  before_filter :load_ransack_search, :only => :index
 
   load_and_authorize_resource
 
   after_filter :update_recently_viewed, :only => :show
 
-  helper_method :entity, :entities, :search
+  helper_method :entity, :entities
 
   # Common attach handler for all core controllers.
   #----------------------------------------------------------------------------
@@ -87,6 +91,17 @@ class EntitiesController < ApplicationController
   def versions
   end
 
+  #----------------------------------------------------------------------------
+  def field_group
+    if @tag = Tag.find_by_name(params[:tag].strip)
+      if @field_group = FieldGroup.find_by_tag_id_and_klass_name(@tag.id, klass.to_s)
+        @asset = klass.find_by_id(params[:asset_id]) || klass.new
+        render 'fields/group' and return
+      end
+    end
+    render :text => ''
+  end
+
 protected
 
   #----------------------------------------------------------------------------
@@ -108,50 +123,63 @@ protected
   def entities
     instance_variable_get("@#{controller_name}") || klass.my
   end
+  
+  def set_options
+    unless params[:cancel].true?
+      klass = controller_name.classify.constantize
+      action = params['action']
+      @per_page = current_user.pref[:"#{controller_name}_per_page"] || klass.per_page
+      @sort_by  = current_user.pref[:"#{controller_name}_sort_by"]  || klass.sort_by
+    end
+  end
 
 private
 
-  #----------------------------------------------------------------------------
-  def get_users
-    @users ||= User.except(current_user)
-  end
-
-  #----------------------------------------------------------------------------
-  def search
-    @search ||= begin
-      search = klass.search(params[:q])
-      search.build_grouping unless search.groupings.any?
-      search
-    end
+  def ransack_search
+    @ransack_search ||= load_ransack_search
+    @ransack_search.build_sort if @ransack_search.sorts.empty?
+    @ransack_search
   end
 
   # Get list of records for a given model class.
   #----------------------------------------------------------------------------
   def get_list_of_records(options = {})
-    options[:query] ||= params[:query]                        if params[:query]
-    self.current_page = options[:page]                        if options[:page]
-    query, tags       = parse_query_and_tags(options[:query]) if options[:query]
+    options[:query]  ||= params[:query]                        if params[:query]
+    self.current_page  = options[:page]                        if options[:page]
+    query, tags        = parse_query_and_tags(options[:query])
     self.current_query = query
+    advanced_search = params[:q].present?
+    wants = request.format
 
-    order = current_user.pref[:"#{controller_name}_sort_by"] || klass.sort_by
-
-    pages = {
-      :page     => current_page,
-      :per_page => current_user.pref[:"#{controller_name}_per_page"]
-    }
+    scope = entities.merge(ransack_search.result(:distinct => true))
 
-    # Use default processing if no hooks are present. Note that comma-delimited
-    # export includes deleted records, and the pagination is enabled only for
-    # plain HTTP, Ajax and XML API requests.
-    wants = request.format
-    filter = session[:"#{controller_name}_filter"].to_s.split(',')
+    # Get filter from session, unless running an advanced search
+    unless advanced_search
+      filter = session[:"#{controller_name}_filter"].to_s.split(',')
+      scope = scope.state(filter) if filter.present?
+    end
 
-    scope = entities.merge(search.result)
-    scope = scope.state(filter)                   if filter.present?
     scope = scope.text_search(query)              if query.present?
     scope = scope.tagged_with(tags, :on => :tags) if tags.present?
-    scope = scope.order(order)
-    scope = scope.paginate(pages)                 if wants.html? || wants.js? || wants.xml?
+
+    # Ignore this order when doing advanced search
+    unless advanced_search
+      order = current_user.pref[:"#{controller_name}_sort_by"] || klass.sort_by
+      scope = scope.order(order)
+    end
+
+    @search_results_count = scope.count
+
+    # Pagination is disabled for xls and csv requests
+    unless (wants.xls? || wants.csv?)
+      per_page = if options[:per_page]
+        options[:per_page] == 'all' ? @search_results_count : options[:per_page]
+      else
+        current_user.pref[:"#{controller_name}_per_page"]
+      end
+      scope = scope.paginate(:page => current_page, :per_page => per_page)
+    end
+    
     scope
   end
 
@@ -160,25 +188,15 @@ private
     entity.versions.create(:event => :view, :whodunnit => PaperTrail.whodunnit)
   end
 
-  #----------------------------------------------------------------------------
-  def field_group
-    if @tag = Tag.find_by_name(params[:tag].strip)
-      if @field_group = FieldGroup.find_by_tag_id_and_klass_name(@tag.id, klass.to_s)
-        @asset = klass.find_by_id(params[:asset_id]) || klass.new
-        render 'fields/group' and return
-      end
-    end
-    render :text => ''
-  end
-
   # Somewhat simplistic parser that extracts query and hash-prefixed tags from
   # the search string and returns them as two element array, for example:
   #
   # "#real Billy Bones #pirate" => [ "Billy Bones", "real, pirate" ]
   #----------------------------------------------------------------------------
   def parse_query_and_tags(search_string)
+    return ['', ''] if search_string.blank?
     query, tags = [], []
-    search_string.scan(/[\w@\-\.#]+/).each do |token|
+    search_string.strip.split(/\s+/).each do |token|
       if token.starts_with?("#")
         tags << token[1 .. -1]
       else
@@ -192,4 +210,14 @@ private
   def timeline(asset)
     (asset.comments + asset.emails).sort { |x, y| y.created_at <=> x.created_at }
   end
+
+  # Sets the current template view for entities in this context
+  #----------------------------------------------------------------------------
+  def set_view
+    if params['view']
+      controller = params['controller']
+      action = (params['action'] == 'show') ? 'show' : 'index' # create update redraw filter index actions all use index view
+      current_user.pref[:"#{controller}_#{action}_view"] = params['view']
+    end
+  end
 end

data/app/controllers/home_controller.rb

@@ -26,6 +26,9 @@ class HomeController < ApplicationController
     hook(:home_controller, self, :params => "it works!")
 
     @activities = get_activities
+    @my_tasks = Task.visible_on_dashboard(current_user).by_due_at
+    @my_opportunities = Opportunity.visible_on_dashboard(current_user).by_closes_on.by_amount
+    @my_accounts = Account.visible_on_dashboard(current_user).by_name
     respond_with(@activities)
   end
 
@@ -33,10 +36,10 @@ class HomeController < ApplicationController
   #----------------------------------------------------------------------------
   def options
     unless params[:cancel].true?
-      @asset = @current_user.pref[:activity_asset] || "all"
-      @action = @current_user.pref[:activity_event] || "all_events"
-      @user = @current_user.pref[:activity_user] || "all_users"
-      @duration = @current_user.pref[:activity_duration] || "two_days"
+      @asset = current_user.pref[:activity_asset] || "all"
+      @action = current_user.pref[:activity_event] || "all_events"
+      @user = current_user.pref[:activity_user] || "all_users"
+      @duration = current_user.pref[:activity_duration] || "two_days"
       @all_users = User.order("first_name, last_name")
     end
   end
@@ -44,10 +47,10 @@ class HomeController < ApplicationController
   # POST /home/redraw                                                      AJAX
   #----------------------------------------------------------------------------
   def redraw
-    @current_user.pref[:activity_asset] = params[:asset] if params[:asset]
-    @current_user.pref[:activity_event] = params[:event] if params[:event]
-    @current_user.pref[:activity_user] = params[:user] if params[:user]
-    @current_user.pref[:activity_duration] = params[:duration] if params[:duration]
+    current_user.pref[:activity_asset] = params[:asset] if params[:asset]
+    current_user.pref[:activity_event] = params[:event] if params[:event]
+    current_user.pref[:activity_user] = params[:user] if params[:user]
+    current_user.pref[:activity_duration] = params[:duration] if params[:duration]
 
     @activities = get_activities
     render :index
@@ -101,13 +104,14 @@ class HomeController < ApplicationController
     options[:event]    ||= activity_event
     options[:user]     ||= activity_user
     options[:duration] ||= activity_duration
+    options[:max]      ||= 500
 
-    Version.latest(options).visible_to(@current_user)
+    Version.latest(options).visible_to(current_user)
   end
 
   #----------------------------------------------------------------------------
   def activity_asset
-    asset = @current_user.pref[:activity_asset]
+    asset = current_user.pref[:activity_asset]
     if asset.nil? || asset == "all"
       nil
     else
@@ -117,7 +121,7 @@ class HomeController < ApplicationController
 
   #----------------------------------------------------------------------------
   def activity_event
-    event = @current_user.pref[:activity_event]
+    event = current_user.pref[:activity_event]
     if event == "all_events"
       %w(create update destroy)
     else
@@ -127,28 +131,27 @@ class HomeController < ApplicationController
 
   #----------------------------------------------------------------------------
   def activity_user
-    user = @current_user.pref[:activity_user]
-    if user && user != "all users"
-      user = if user =~ /\s/  # first_name middle_name last_name any_name
-        name_query = if user.include?(" ")
-          user.name_permutations.map{ |first, last|
-            "(upper(first_name) LIKE upper('%#{first}%') AND upper(last_name) LIKE upper('%#{last}%'))"
-          }.join(" OR ")
-        else
-          "upper(first_name) LIKE upper('%#{user}%') OR upper(last_name) LIKE upper('%#{user}%')"
+    user = current_user.pref[:activity_user]
+    if user && user != "all_users"
+      user = if user =~ /@/ # email
+          User.where(:email => user).first
+        else # first_name middle_name last_name any_name
+          name_query = if user.include?(" ")
+            user.name_permutations.map{ |first, last|
+              "(upper(first_name) LIKE upper('%#{first}%') AND upper(last_name) LIKE upper('%#{last}%'))"
+            }.join(" OR ")
+          else
+            "upper(first_name) LIKE upper('%#{user}%') OR upper(last_name) LIKE upper('%#{user}%')"
+          end
+          User.where(name_query).first
         end
-
-        User.where(name_query).first
-      elsif user =~ /@/ # email
-        User.where(:email => user).first
-      end
     end
     user.is_a?(User) ? user.id : nil
   end
 
   #----------------------------------------------------------------------------
   def activity_duration
-    duration = @current_user.pref[:activity_duration]
+    duration = current_user.pref[:activity_duration]
     if duration
       words = duration.split("_") # "two_weeks" => 2.weeks
       if %w(one two).include?(words.first)
@@ -158,4 +161,3 @@ class HomeController < ApplicationController
   end
 
 end
-

data/app/controllers/tasks_controller.rb

@@ -19,20 +19,23 @@ class TasksController < ApplicationController
   before_filter :require_user
   before_filter :set_current_tab, :only => [ :index, :show ]
   before_filter :update_sidebar, :only => :index
-
+  
   # GET /tasks
   #----------------------------------------------------------------------------
   def index
     @view = params[:view] || "pending"
-    @tasks = Task.find_all_grouped(@current_user, @view)
+    @tasks = Task.find_all_grouped(current_user, @view)
 
-    respond_with(@tasks)
+    respond_with @tasks do |format|
+      format.xls { render :layout => 'header' }
+      format.csv { render :csv => @tasks.map(&:second).flatten }
+    end
   end
 
   # GET /tasks/1
   #----------------------------------------------------------------------------
   def show
-    @task = Task.tracked_by(@current_user).find(params[:id])
+    @task = Task.tracked_by(current_user).find(params[:id])
 
     respond_with(@task)
   end
@@ -42,12 +45,11 @@ class TasksController < ApplicationController
   def new
     @view = params[:view] || "pending"
     @task = Task.new
-    @users = User.except(@current_user).by_name
     @bucket = Setting.unroll(:task_bucket)[1..-1] << [ t(:due_specific_date, :default => 'On Specific Date...'), :specific_time ]
     @category = Setting.unroll(:task_category)
 
     if params[:related]
-      model, id = params[:related].split('_')
+      model, id = params[:related].split(/_(\d+)/)
       if related = model.classify.constantize.my.find_by_id(id)
         instance_variable_set("@asset", related)
       else
@@ -62,14 +64,13 @@ class TasksController < ApplicationController
   #----------------------------------------------------------------------------
   def edit
     @view = params[:view] || "pending"
-    @task = Task.tracked_by(@current_user).find(params[:id])
-    @users = User.except(@current_user).by_name
+    @task = Task.tracked_by(current_user).find(params[:id])
     @bucket = Setting.unroll(:task_bucket)[1..-1] << [ t(:due_specific_date, :default => 'On Specific Date...'), :specific_time ]
     @category = Setting.unroll(:task_category)
     @asset = @task.asset if @task.asset_id?
 
     if params[:previous].to_s =~ /(\d+)\z/
-      @previous = Task.tracked_by(@current_user).find_by_id($1) || $1.to_i
+      @previous = Task.tracked_by(current_user).find_by_id($1) || $1.to_i
     end
 
     respond_with(@task)
@@ -92,7 +93,7 @@ class TasksController < ApplicationController
   #----------------------------------------------------------------------------
   def update
     @view = params[:view] || "pending"
-    @task = Task.tracked_by(@current_user).find(params[:id])
+    @task = Task.tracked_by(current_user).find(params[:id])
     @task_before_update = @task.clone
 
     if @task.due_at && (@task.due_at < Date.today.to_time)
@@ -105,7 +106,7 @@ class TasksController < ApplicationController
       if @task.update_attributes(params[:task])
         @task.bucket = @task.computed_bucket
         if called_from_index_page?
-          if Task.bucket_empty?(@task_before_update.bucket, @current_user, @view)
+          if Task.bucket_empty?(@task_before_update.bucket, current_user, @view)
             @empty_bucket = @task_before_update.bucket
           end
           update_sidebar
@@ -118,11 +119,11 @@ class TasksController < ApplicationController
   #----------------------------------------------------------------------------
   def destroy
     @view = params[:view] || "pending"
-    @task = Task.tracked_by(@current_user).find(params[:id])
+    @task = Task.tracked_by(current_user).find(params[:id])
     @task.destroy
 
     # Make sure bucket's div gets hidden if we're deleting last task in the bucket.
-    if Task.bucket_empty?(params[:bucket], @current_user, @view)
+    if Task.bucket_empty?(params[:bucket], current_user, @view)
       @empty_bucket = params[:bucket]
     end
 
@@ -133,11 +134,11 @@ class TasksController < ApplicationController
   # PUT /tasks/1/complete
   #----------------------------------------------------------------------------
   def complete
-    @task = Task.tracked_by(@current_user).find(params[:id])
-    @task.update_attributes(:completed_at => Time.now, :completed_by => @current_user.id) if @task
+    @task = Task.tracked_by(current_user).find(params[:id])
+    @task.update_attributes(:completed_at => Time.now, :completed_by => current_user.id) if @task
 
     # Make sure bucket's div gets hidden if it's the last completed task in the bucket.
-    if Task.bucket_empty?(params[:bucket], @current_user)
+    if Task.bucket_empty?(params[:bucket], current_user)
       @empty_bucket = params[:bucket]
     end
 
@@ -179,7 +180,7 @@ private
   def update_sidebar
     @view = params[:view]
     @view = "pending" unless %w(pending assigned completed).include?(@view)
-    @task_total = Task.totals(@current_user, @view)
+    @task_total = Task.totals(current_user, @view)
 
     # Update filters session if we added, deleted, or completed a task.
     if @task

data/app/controllers/users_controller.rb

@@ -19,9 +19,9 @@ class UsersController < ApplicationController
 
   before_filter :require_no_user, :only => [ :new, :create ]
   before_filter :require_user, :only => [ :show, :redraw ]
-  before_filter :set_current_tab, :only => [ :show ] # Don't hightlight any tabs.
+  before_filter :set_current_tab, :only => [ :show, :opportunities_overview ] # Don't hightlight any tabs.
   before_filter :require_and_assign_user, :except => [ :new, :create, :show, :avatar, :upload_avatar ]
-  before_filter :assign_given_or_current_user, :only => [ :show, :avatar, :upload_avatar ]
+  before_filter :assign_given_or_current_user, :only => [ :show, :avatar, :upload_avatar, :edit, :update ]
 
   load_resource
 
@@ -76,7 +76,6 @@ class UsersController < ApplicationController
   #----------------------------------------------------------------------------
   def update
     @user.update_attributes(params[:user])
-
     respond_with(@user)
   end
 
@@ -146,19 +145,24 @@ class UsersController < ApplicationController
   # POST /users/1/redraw                                                   AJAX
   #----------------------------------------------------------------------------
   def redraw
-    @current_user.preference[:locale] = params[:locale]
-    render(:update) { |page| page.redirect_to user_path(@current_user) }
+    current_user.preference[:locale] = params[:locale]
+    render(:update) { |page| page.redirect_to user_path(current_user) }
+  end
+
+  def opportunities_overview
+    @users_with_opportunities = User.have_assigned_opportunities.order(:first_name)
+    @unassigned_opportunities = Opportunity.unassigned.pipeline.order(:stage)
   end
 
-private
+  private
 
   #----------------------------------------------------------------------------
   def require_and_assign_user
     require_user
-    @user = @current_user
+    @user = current_user
   end
 
   def assign_given_or_current_user
-    @user = params[:id] ? User.find(params[:id]) : @current_user
+    @user = params[:id] ? User.find(params[:id]) : current_user
   end
 end

data/app/helpers/accounts_helper.rb

@@ -19,15 +19,8 @@ module AccountsHelper
 
   # Sidebar checkbox control for filtering accounts by category.
   #----------------------------------------------------------------------------
-  def account_category_checbox(category, count)
-    checked = (session[:accounts_filter] ? session[:accounts_filter].split(",").include?(category.to_s) : count.to_i > 0)
-    onclick = remote_function(
-      :url      => { :action => :filter },
-      :with     => h(%Q/"category=" + $$("input[name='category[]']").findAll(function (el) { return el.checked }).pluck("value")/),
-      :loading  => "$('loading').show()",
-      :complete => "$('loading').hide()"
-    )
-    check_box_tag("category[]", category, checked, :id => category, :onclick => onclick)
+  def account_category_checkbox(category, count)
+    entity_filter_checkbox(:category, category, count)
   end
 
   # Quick account summary for RSS/ATOM feeds.
@@ -40,7 +33,7 @@ module AccountsHelper
       t('pluralize.comment', account.comments.count)
     ].join(', ')
   end
-  
+
   def account_select(options = {})
       # Generates a select list with the first 25 accounts,
       # and prepends the currently selected account, if available
@@ -50,28 +43,77 @@ module AccountsHelper
                         {:"data-placeholder" => t(:select_an_account),
                          :style => "width:330px; display:none;" }
   end
-  
+
   # Select an existing account or create a new one.
   #----------------------------------------------------------------------------
   def account_select_or_create(form, &block)
     options = {}
     yield options if block_given?
-    
+
     content_tag(:div, :class => 'label') do
       t(:account).html_safe +
-    
+
       content_tag(:span, :id => 'account_create_title') do
         "(#{t :create_new} #{t :or} <a href='#' onclick='crm.select_account(1); return false;'>#{t :select_existing}</a>):".html_safe
       end.html_safe +
-    
+
       content_tag(:span, :id => 'account_select_title') do
         "(<a href='#' onclick='crm.create_account(1); return false;'>#{t :create_new}</a> #{t :or} #{t :select_existing}):".html_safe
       end.html_safe +
-    
+
       content_tag(:span, ':', :id => 'account_disabled_title').html_safe
     end.html_safe +
-    
+
     account_select(options).html_safe +
     form.text_field(:name, :style => 'width:324px; display:none;')
   end
+
+  # Output account url for a given contact
+  # - a helper so it is easy to override in plugins that allow for several accounts
+  #----------------------------------------------------------------------------
+  def account_with_url_for(contact)
+    contact.account ? link_to(h(contact.account.name), account_path(contact.account)) : ""
+  end
+
+  # Output account with title and department
+  # - a helper so it is easy to override in plugins that allow for several accounts
+  #----------------------------------------------------------------------------
+  def account_with_title_and_department(contact)
+    text = if !contact.title.blank? && contact.account
+        # works_at: "{{h(job_title)}} at {{h(company)}}"
+        content_tag :div, t(:works_at, :job_title => h(contact.title), :company => account_with_url_for(contact)).html_safe
+      elsif !contact.title.blank?
+        content_tag :div, h(contact.title)
+      elsif contact.account
+        content_tag :div, account_with_url_for(contact)
+      end
+    text << t(:department_small, h(contact.department)) unless contact.department.blank?
+    text
+  end
+  
+  # "title, department at Account name" used in index_brief and index_long
+  # - a helper so it is easy to override in plugins that allow for several accounts
+  #----------------------------------------------------------------------------
+  def brief_account_info(contact)
+    text = ""
+    title = contact.title
+    department = contact.department
+    account = contact.account
+    account_text = ""
+    account_text = link_to_if(can?(:read, account), h(account.name), account_path(account)) if account.present?
+
+    text << if title.present? && department.present?
+          t(:account_with_title_department, :title => h(title), :department => h(department), :account => account_text)
+        elsif title.present?
+          t(:account_with_title, :title => h(title), :account => account_text)
+        elsif department.present?
+          t(:account_with_title, :title => h(department), :account => account_text)
+        elsif account_text.present?
+          t(:works_at, :job_title => "", :company => account_text)
+        else
+          ""
+        end
+    text.html_safe
+  end
+  
 end