fat_free_crm 0.11.1 → 0.11.2

data/app/controllers/entities/leads_controller.rb

@@ -28,57 +28,51 @@ class LeadsController < EntitiesController
   # GET /leads/1
   #----------------------------------------------------------------------------
   def show
-    @lead = Lead.my.find(params[:id])
-
     respond_with(@lead) do |format|
       format.html do
         @comment = Comment.new
         @timeline = timeline(@lead)
       end
     end
-
-  rescue ActiveRecord::RecordNotFound
-    respond_to_not_found(:html, :json, :xml)
   end
 
   # GET /leads/new
   #----------------------------------------------------------------------------
   def new
-    @lead = Lead.new(:user => @current_user, :access => Setting.default_access)
+    @lead.attributes = {:user => @current_user, :access => Setting.default_access}
     @users = User.except(@current_user)
-    @campaigns = Campaign.my.order("name")
+    get_campaigns
+
     if params[:related]
-      model, id = params[:related].split("_")
-      instance_variable_set("@#{model}", model.classify.constantize.my.find(id))
+      model, id = params[:related].split('_')
+      if related = model.classify.constantize.my.find_by_id(id)
+        instance_variable_set("@#{model}", related)
+      else
+        respond_to_related_not_found(model) and return
+      end
     end
-    respond_with(@lead)
 
-  rescue ActiveRecord::RecordNotFound # Kicks in if related asset was not found.
-    respond_to_related_not_found(model, :js) if model
+    respond_with(@lead)
   end
 
   # GET /leads/1/edit                                                      AJAX
   #----------------------------------------------------------------------------
   def edit
-    @lead = Lead.my.find(params[:id])
     @users = User.except(@current_user)
-    @campaigns = Campaign.my.order("name")
+    get_campaigns
+
     if params[:previous].to_s =~ /(\d+)\z/
-      @previous = Lead.my.find($1)
+      @previous = Lead.my.find_by_id($1) || $1.to_i
     end
-    respond_with(@lead)
 
-  rescue ActiveRecord::RecordNotFound
-    @previous ||= $1.to_i
-    respond_to_not_found(:js) unless @lead
+    respond_with(@lead)
   end
 
   # POST /leads
   #----------------------------------------------------------------------------
   def create
-    @lead = Lead.new(params[:lead])
     @users = User.except(@current_user)
-    @campaigns = Campaign.my.order("name")
+    get_campaigns
 
     respond_with(@lead) do |format|
       if @lead.save_with_permissions(params)
@@ -95,61 +89,48 @@ class LeadsController < EntitiesController
   # PUT /leads/1
   #----------------------------------------------------------------------------
   def update
-    @lead = Lead.my.find(params[:id])
-
     respond_with(@lead) do |format|
       if @lead.update_with_permissions(params[:lead], params[:users])
         update_sidebar
       else
         @users = User.except(@current_user)
-        @campaigns = Campaign.my.order("name")
+        @campaigns = Campaign.my.order('name')
       end
     end
-
-  rescue ActiveRecord::RecordNotFound
-    respond_to_not_found(:js, :json, :xml)
   end
 
   # DELETE /leads/1
   #----------------------------------------------------------------------------
   def destroy
-    @lead = Lead.my.find(params[:id])
-    @lead.destroy if @lead
+    @lead.destroy
 
     respond_with(@lead) do |format|
       format.html { respond_to_destroy(:html) }
       format.js   { respond_to_destroy(:ajax) }
     end
-
-  rescue ActiveRecord::RecordNotFound
-    respond_to_not_found(:html, :js, :json, :xml)
   end
 
   # GET /leads/1/convert
   #----------------------------------------------------------------------------
   def convert
-    @lead = Lead.my.find(params[:id])
     @users = User.except(@current_user)
     @account = Account.new(:user => @current_user, :name => @lead.company, :access => "Lead")
-    @accounts = Account.my.order("name")
+    @accounts = Account.my.order('name')
     @opportunity = Opportunity.new(:user => @current_user, :access => "Lead", :stage => "prospecting", :campaign => @lead.campaign, :source => @lead.source)
+
     if params[:previous].to_s =~ /(\d+)\z/
-      @previous = Lead.my.find($1)
+      @previous = Lead.my.find_by_id($1) || $1.to_i
     end
-    respond_with(@lead)
 
-  rescue ActiveRecord::RecordNotFound
-    @previous ||= $1.to_i
-    respond_to_not_found(:js, :json, :xml) unless @lead
+    respond_with(@lead)
   end
 
   # PUT /leads/1/promote
   #----------------------------------------------------------------------------
   def promote
-    @lead = Lead.my.find(params[:id])
     @users = User.except(@current_user)
     @account, @opportunity, @contact = @lead.promote(params)
-    @accounts = Account.my.order("name")
+    @accounts = Account.my.order('name')
     @stage = Setting.unroll(:opportunity_stage)
 
     respond_with(@lead) do |format|
@@ -161,33 +142,26 @@ class LeadsController < EntitiesController
         format.xml  { render :xml => @account.errors + @opportunity.errors + @contact.errors, :status => :unprocessable_entity }
       end
     end
-
-  rescue ActiveRecord::RecordNotFound
-    respond_to_not_found(:js, :json, :xml)
   end
 
   # PUT /leads/1/reject
   #----------------------------------------------------------------------------
   def reject
-    @lead = Lead.my.find(params[:id])
-    @lead.reject if @lead
+    @lead.reject
     update_sidebar
 
     respond_with(@lead) do |format|
       format.html { flash[:notice] = t(:msg_asset_rejected, @lead.full_name); redirect_to leads_path }
     end
-
-  rescue ActiveRecord::RecordNotFound
-    respond_to_not_found(:html, :js, :json, :xml)
   end
 
   # PUT /leads/1/attach
   #----------------------------------------------------------------------------
-  # Handled by ApplicationController :attach
+  # Handled by EntitiesController :attach
 
   # POST /leads/1/discard
   #----------------------------------------------------------------------------
-  # Handled by ApplicationController :discard
+  # Handled by EntitiesController :discard
 
   # POST /leads/auto_complete/query                                        AJAX
   #----------------------------------------------------------------------------
@@ -229,15 +203,19 @@ class LeadsController < EntitiesController
   # POST /leads/filter                                                     AJAX
   #----------------------------------------------------------------------------
   def filter
-    session[:filter_by_lead_status] = params[:status]
+    session[:leads_filter] = params[:status]
     @leads = get_leads(:page => 1) # Start one the first page.
     render :index
   end
 
-  private
+private
+
+  #----------------------------------------------------------------------------
+  alias :get_leads :get_list_of_records
+
   #----------------------------------------------------------------------------
-  def get_leads(options = {})
-    get_list_of_records(Lead, options.merge!(:filter => :filter_by_lead_status))
+  def get_campaigns
+    @campaigns = Campaign.my.order('name')
   end
 
   #----------------------------------------------------------------------------

data/app/controllers/entities/opportunities_controller.rb

@@ -18,7 +18,7 @@
 class OpportunitiesController < EntitiesController
   before_filter :load_settings
   before_filter :get_data_for_sidebar, :only => :index
-  before_filter :set_params, :only => [:index, :redraw, :filter]
+  before_filter :set_params, :only => [ :index, :redraw, :filter ]
 
   # GET /opportunities
   #----------------------------------------------------------------------------
@@ -30,58 +30,51 @@ class OpportunitiesController < EntitiesController
   # GET /opportunities/1
   #----------------------------------------------------------------------------
   def show
-    @opportunity = Opportunity.my.find(params[:id])
-
     respond_with(@opportunity) do |format|
       format.html do
         @comment = Comment.new
         @timeline = timeline(@opportunity)
       end
     end
-
-  rescue ActiveRecord::RecordNotFound
-    respond_to_not_found(:html, :json, :xml)
   end
 
   # GET /opportunities/new
   #----------------------------------------------------------------------------
   def new
-    @opportunity = Opportunity.new(:user => @current_user, :stage => "prospecting", :access => Setting.default_access)
+    @opportunity.attributes = {:user => @current_user, :stage => "prospecting", :access => Setting.default_access}
     @users       = User.except(@current_user)
-    @account     = Account.new(:user => @current_user)
-    @accounts    = Account.my.order("name")
+    @account     = Account.new(:user => @current_user, :access => Setting.default_access)
+    @accounts    = Account.my.order('name')
+
     if params[:related]
-      model, id = params[:related].split("_")
-      instance_variable_set("@#{model}", model.classify.constantize.my.find(id))
+      model, id = params[:related].split('_')
+      if related = model.classify.constantize.my.find_by_id(id)
+        instance_variable_set("@#{model}", related)
+      else
+        respond_to_related_not_found(model) and return
+      end
     end
-    respond_with(@opportunity)
 
-  rescue ActiveRecord::RecordNotFound # Kicks in if related asset was not found.
-    respond_to_related_not_found(model, :js) if model
+    respond_with(@opportunity)
   end
 
   # GET /opportunities/1/edit                                              AJAX
   #----------------------------------------------------------------------------
   def edit
-    @opportunity = Opportunity.my.find(params[:id])
     @users = User.except(@current_user)
     @account  = @opportunity.account || Account.new(:user => @current_user)
-    @accounts = Account.my.order("name")
+    @accounts = Account.my.order('name')
+
     if params[:previous].to_s =~ /(\d+)\z/
-      @previous = Opportunity.my.find($1)
+      @previous = Opportunity.my.find_by_id($1) || $1.to_i
     end
-    respond_with(@opportunity)
 
-  rescue ActiveRecord::RecordNotFound
-    @previous ||= $1.to_i
-    respond_to_not_found(:js) unless @opportunity
+    respond_with(@opportunity)
   end
 
   # POST /opportunities
   #----------------------------------------------------------------------------
   def create
-    @opportunity = Opportunity.new(params[:opportunity])
-
     respond_with(@opportunity) do |format|
       if @opportunity.save_with_account_and_permissions(params)
         if called_from_index_page?
@@ -94,7 +87,7 @@ class OpportunitiesController < EntitiesController
         end
       else
         @users = User.except(@current_user)
-        @accounts = Account.my.order("name")
+        @accounts = Account.my.order('name')
         unless params[:account][:id].blank?
           @account = Account.find(params[:account][:id])
         else
@@ -113,8 +106,6 @@ class OpportunitiesController < EntitiesController
   # PUT /opportunities/1
   #----------------------------------------------------------------------------
   def update
-    @opportunity = Opportunity.my.find(params[:id])
-
     respond_with(@opportunity) do |format|
       if @opportunity.update_with_account_and_permissions(params)
         if called_from_index_page?
@@ -126,7 +117,7 @@ class OpportunitiesController < EntitiesController
         end
       else
         @users = User.except(@current_user)
-        @accounts = Account.my.order("name")
+        @accounts = Account.my.order('name')
         if @opportunity.account
           @account = Account.find(@opportunity.account.id)
         else
@@ -134,38 +125,31 @@ class OpportunitiesController < EntitiesController
         end
       end
     end
-
-  rescue ActiveRecord::RecordNotFound
-    respond_to_not_found(:js, :json, :xml)
   end
 
   # DELETE /opportunities/1
   #----------------------------------------------------------------------------
   def destroy
-    @opportunity = Opportunity.my.find(params[:id])
     if called_from_landing_page?(:accounts)
       @account = @opportunity.account   # Reload related account if any.
     elsif called_from_landing_page?(:campaigns)
       @campaign = @opportunity.campaign # Reload related campaign if any.
     end
-    @opportunity.destroy if @opportunity
+    @opportunity.destroy
 
     respond_with(@opportunity) do |format|
       format.html { respond_to_destroy(:html) }
       format.js   { respond_to_destroy(:ajax) }
     end
-
-  rescue ActiveRecord::RecordNotFound
-    respond_to_not_found(:html, :js, :json, :xml)
   end
 
   # PUT /opportunities/1/attach
   #----------------------------------------------------------------------------
-  # Handled by ApplicationController :attach
+  # Handled by EntitiesController :attach
 
   # POST /opportunities/1/discard
   #----------------------------------------------------------------------------
-  # Handled by ApplicationController :discard
+  # Handled by EntitiesController :discard
 
   # POST /opportunities/auto_complete/query                                AJAX
   #----------------------------------------------------------------------------
@@ -195,11 +179,10 @@ class OpportunitiesController < EntitiesController
     render :index
   end
 
-  private
+private
+
   #----------------------------------------------------------------------------
-  def get_opportunities(options = {})
-    get_list_of_records(Opportunity, options.merge!(:filter => :filter_by_opportunity_stage))
-  end
+  alias :get_opportunities :get_list_of_records
 
   #----------------------------------------------------------------------------
   def respond_to_destroy(method)
@@ -241,10 +224,11 @@ class OpportunitiesController < EntitiesController
     @stage = Setting.unroll(:opportunity_stage)
   end
 
+  #----------------------------------------------------------------------------
   def set_params
     @current_user.pref[:opportunities_per_page] = params[:per_page] if params[:per_page]
     @current_user.pref[:opportunities_outline]  = params[:outline]  if params[:outline]
     @current_user.pref[:opportunities_sort_by]  = Opportunity::sort_by_map[params[:sort_by]] if params[:sort_by]
-    session[:filter_by_opportunity_stage] = params[:stage] if params[:stage]
+    session[:opportunities_filter] = params[:stage] if params[:stage]
   end
 end

data/app/controllers/entities_controller.rb

@@ -18,119 +18,105 @@
 class EntitiesController < ApplicationController
   before_filter :require_user
   before_filter :set_current_tab, :only => [ :index, :show ]
-  after_filter  :update_recently_viewed, :only => :show
 
-  respond_to :html, :only => [ :index, :show, :auto_complete ]
-  respond_to :js
-  respond_to :json, :xml, :except => :edit
-  respond_to :atom, :csv, :rss, :xls, :only => :index
+  load_and_authorize_resource
 
-  helper_method :search
+  after_filter :update_recently_viewed, :only => :show
 
-  # Common auto_complete handler for all core controllers.
-  #----------------------------------------------------------------------------
-  def auto_complete
-    @query = params[:auto_complete_query]
-    @auto_complete = hook(:auto_complete, self, :query => @query, :user => @current_user)
-    if @auto_complete.empty?
-      @auto_complete = klass.my.text_search(@query).limit(10)
-    else
-      @auto_complete = @auto_complete.last
-    end
-    session[:auto_complete] = controller_name.to_sym
-    respond_to do |format|
-      format.any(:js, :html)   { render "shared/auto_complete", :layout => nil }
-      format.json { render :json => @auto_complete.inject({}){|h,a| h[a.id] = a.name; h } }
-    end
-  end
+  helper_method :entity, :entities, :search
 
   # Common attach handler for all core controllers.
   #----------------------------------------------------------------------------
   def attach
-    model = klass.my.find(params[:id])
     @attachment = params[:assets].classify.constantize.find(params[:asset_id])
-    @attached = model.attach!(@attachment)
-    @account  = model.reload if model.is_a?(Account)
-    @campaign = model.reload if model.is_a?(Campaign)
-
-    respond_to do |format|
-      format.js   { render "shared/attach" }
-      format.json { render :json => model.reload }
-      format.xml  { render :xml => model.reload }
-    end
+    @attached = entity.attach!(@attachment)
+    entity.reload
 
-  rescue ActiveRecord::RecordNotFound
-    respond_to_not_found(:html, :js, :json, :xml)
+    respond_with(entity)
   end
 
   # Common discard handler for all core controllers.
   #----------------------------------------------------------------------------
   def discard
-    model = klass.my.find(params[:id])
     @attachment = params[:attachment].constantize.find(params[:attachment_id])
-    model.discard!(@attachment)
-    @account  = model.reload if model.is_a?(Account)
-    @campaign = model.reload if model.is_a?(Campaign)
-
-    respond_to do |format|
-      format.js   { render "shared/discard" }
-      format.json { render :json => model.reload }
-      format.xml  { render :xml => model.reload }
+    entity.discard!(@attachment)
+    entity.reload
+
+    respond_with(entity)
+  end
+
+  # Common subscribe handler for all core controllers.
+  #----------------------------------------------------------------------------
+  def subscribe
+    entity.subscribed_users += [current_user.id]
+    entity.save
+
+    respond_with(entity) do |format|
+      format.js { render 'subscription_update' }
     end
+  end
 
-  rescue ActiveRecord::RecordNotFound
-    respond_to_not_found(:html, :js, :json, :xml)
+  # Common unsubscribe handler for all core controllers.
+  #----------------------------------------------------------------------------
+  def unsubscribe
+    entity.subscribed_users -= [current_user.id]
+    entity.save
+
+    respond_with(entity) do |format|
+      format.js { render 'subscription_update' }
+    end
   end
 
   # GET /entities/contacts                                                 AJAX
   #----------------------------------------------------------------------------
   def contacts
-    @entity = klass.my.find(params[:id])
   end
 
   # GET /entities/leads                                                    AJAX
   #----------------------------------------------------------------------------
   def leads
-    @entity = klass.my.find(params[:id])
   end
 
   # GET /entities/opportunities                                            AJAX
   #----------------------------------------------------------------------------
   def opportunities
-    @entity = klass.my.find(params[:id])
   end
 
   # GET /entities/versions                                                 AJAX
   #----------------------------------------------------------------------------
   def versions
-    @entity = klass.my.find(params[:id])
   end
 
-  def timeline(asset)
-    (asset.comments + asset.emails).sort { |x, y| y.created_at <=> x.created_at }
+protected
+
+  #----------------------------------------------------------------------------
+  def entity=(entity)
+    instance_variable_set("@#{controller_name.singularize}", entity)
   end
 
-  # Controller instance method that responds to /controlled/tagged/tag request.
-  # It stores given tag as current query and redirect to index to display all
-  # records tagged with the tag.
   #----------------------------------------------------------------------------
-  def tagged
-    self.send(:current_query=, "#" << params[:id]) unless params[:id].blank?
-    redirect_to :action => "index"
+  def entity
+    instance_variable_get("@#{controller_name.singularize}")
   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 => ''
+  #----------------------------------------------------------------------------
+  def entities=(entities)
+    instance_variable_set("@#{controller_name}", entities)
   end
 
-  private
+  #----------------------------------------------------------------------------
+  def entities
+    instance_variable_get("@#{controller_name}") || klass.my
+  end
 
+private
+
+  #----------------------------------------------------------------------------
+  def get_users
+    @users ||= User.except(current_user)
+  end
+
+  #----------------------------------------------------------------------------
   def search
     @search ||= begin
       search = klass.search(params[:q])
@@ -141,46 +127,69 @@ class EntitiesController < ApplicationController
 
   # Get list of records for a given model class.
   #----------------------------------------------------------------------------
-  def get_list_of_records(klass, options = {})
-    items = klass.name.tableize
+  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]
     self.current_query = query
 
-    records = {
-      :user  => current_user,
-      :order => current_user.pref[:"#{items}_sort_by"] || klass.sort_by
-    }
+    order = current_user.pref[:"#{controller_name}_sort_by"] || klass.sort_by
+
     pages = {
       :page     => current_page,
-      :per_page => current_user.pref[:"#{items}_per_page"]
+      :per_page => current_user.pref[:"#{controller_name}_per_page"]
     }
 
-    # Call the hook and return its output if any.
-    assets = hook(:"get_#{items}", self, :records => records, :pages => pages)
-    return assets.last unless assets.empty?
-
     # 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[options[:filter]].to_s.split(',') if options[:filter]
+    filter = session[:"#{controller_name}_filter"].to_s.split(',')
 
-    scope = klass.my(records)
-    scope = scope.merge(search.result)
+    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.unscoped                        if wants.csv?
+    scope = scope.order(order)
     scope = scope.paginate(pages)                 if wants.html? || wants.js? || wants.xml?
     scope
   end
 
   #----------------------------------------------------------------------------
   def update_recently_viewed
-    if item = instance_variable_get("@#{controller_name.singularize}")
-      item.send(item.class.versions_association_name).create(:event => :view, :whodunnit => PaperTrail.whodunnit)
+    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)
+    query, tags = [], []
+    search_string.scan(/[\w@\-\.#]+/).each do |token|
+      if token.starts_with?("#")
+        tags << token[1 .. -1]
+      else
+        query << token
+      end
     end
+    [ query.join(" "), tags.join(", ") ]
+  end
+
+  #----------------------------------------------------------------------------
+  def timeline(asset)
+    (asset.comments + asset.emails).sort { |x, y| y.created_at <=> x.created_at }
   end
 end