fat_free_crm 0.11.1 → 0.11.2

data/app/controllers/admin/settings_controller.rb

@@ -22,10 +22,6 @@ class Admin::SettingsController < Admin::ApplicationController
   # GET /admin/settings.xml
   #----------------------------------------------------------------------------
   def index
-    respond_to do |format|
-      format.html # index.html.haml
-      format.xml  { render :xml => nil }
-    end
   end
 end
 

data/app/controllers/admin/tags_controller.rb

@@ -18,114 +18,59 @@
 class Admin::TagsController < Admin::ApplicationController
   before_filter "set_current_tab('admin/tags')", :only => [ :index, :show ]
 
+  load_resource
+
   # GET /admin/tags
   # GET /admin/tags.xml                                                   HTML
   #----------------------------------------------------------------------------
   def index
-    @tags = Tag.all
-
-    respond_to do |format|
-      format.html # index.html.haml
-      format.js   # index.js.rjs
-      format.xml  { render :xml => Tag.all }
-      format.xls  { send_data @tags.to_xls, :type => :xls }
-      format.csv  { send_data @tags.to_csv, :type => :csv }
-      format.rss  { render "shared/index.rss.builder" }
-      format.atom { render "shared/index.atom.builder" }
-    end
+    respond_with(@tags)
   end
 
   # GET /admin/tags/new
   # GET /admin/tags/new.xml                                               AJAX
   #----------------------------------------------------------------------------
   def new
-    @tag = Tag.new
-
-    respond_to do |format|
-      format.js   # new.js.rjs
-      format.xml  { render :xml => @tag }
-    end
+    respond_with(@tag)
   end
 
   # GET /admin/tags/1/edit                                                AJAX
   #----------------------------------------------------------------------------
   def edit
-    @tag = Tag.find(params[:id])
-
     if params[:previous].to_s =~ /(\d+)\z/
-      @previous = Tag.find($1)
+      @previous = Tag.find_by_id($1) || $1.to_i
     end
-
-  rescue ActiveRecord::RecordNotFound
-    @previous ||= $1.to_i
-    respond_to_not_found(:js) unless @tag
   end
 
   # POST /admin/tags
   # POST /admin/tags.xml                                                  AJAX
   #----------------------------------------------------------------------------
   def create
-    @tag = Tag.new(params[:tag])
+    @tag.update_attributes(params[:tag])
 
-    respond_to do |format|
-      if @tag.save
-        @tags = Tag.all
-        format.js   # create.js.rjs
-        format.xml  { render :xml => @tag, :status => :created, :location => @tag }
-      else
-        format.js   # create.js.rjs
-        format.xml  { render :xml => @tag.errors, :status => :unprocessable_entity }
-      end
-    end
+    respond_with(@tag)
   end
 
   # PUT /admin/tags/1
   # PUT /admin/tags/1.xml                                                 AJAX
   #----------------------------------------------------------------------------
   def update
-    @tag = Tag.find(params[:id])
+    @tag.update_attributes(params[:tag])
 
-    respond_to do |format|
-      if @tag.update_attributes(params[:tag])
-        format.js   # update.js.rjs
-        format.xml  { head :ok }
-      else
-        format.js   # update.js.rjs
-        format.xml  { render :xml => @tag.errors, :status => :unprocessable_entity }
-      end
-    end
-
-  rescue ActiveRecord::RecordNotFound
-    respond_to_not_found(:js, :xml)
+    respond_with(@tag)
   end
 
-
   # DELETE /admin/tags/1
   # DELETE /admin/tags/1.xml                                              AJAX
   #----------------------------------------------------------------------------
   def destroy
-    @tag = Tag.find(params[:id])
+    @tag.destroy
 
-    respond_to do |format|
-      if @tag.destroy
-        format.js   # destroy.js.rjs
-        format.xml  { head :ok }
-      else
-        flash[:warning] = t(:msg_cant_delete_tag, @tag.name)
-        format.js   # destroy.js.rjs
-        format.xml  { render :xml => @tag.errors, :status => :unprocessable_entity }
-      end
-    end
+    respond_with(@tag)
   end
 
   # GET /admin/tags/1/confirm                                             AJAX
   #----------------------------------------------------------------------------
   def confirm
-    @tag = Tag.find(params[:id])
-
-  rescue ActiveRecord::RecordNotFound
-    respond_to_not_found(:js, :xml)
   end
-
 end
-

data/app/controllers/admin/users_controller.rb

@@ -18,59 +18,38 @@
 class Admin::UsersController < Admin::ApplicationController
   before_filter "set_current_tab('admin/users')", :only => [ :index, :show ]
 
+  load_resource
+
   # GET /admin/users
   # GET /admin/users.xml                                                   HTML
   #----------------------------------------------------------------------------
   def index
     @users = get_users(:page => params[:page])
-
-    respond_to do |format|
-      format.html # index.html.haml
-      format.js   # index.js.rjs
-      format.xml  { render :xml => User.all }
-      format.xls  { send_data @users.to_xls, :type => :xls }
-      format.csv  { send_data @users.to_csv, :type => :csv }
-      format.rss  { render "shared/index.rss.builder" }
-      format.atom { render "shared/index.atom.builder" }
-    end
+    respond_with(@users)
   end
 
   # GET /admin/users/1
   # GET /admin/users/1.xml
   #----------------------------------------------------------------------------
   def show
-    @user = User.find(params[:id])
-
-    respond_to do |format|
-      format.html # show.html.haml
-      format.xml  { render :xml => @user }
-    end
+    respond_with(@user)
   end
 
   # GET /admin/users/new
   # GET /admin/users/new.xml                                               AJAX
   #----------------------------------------------------------------------------
   def new
-    @user = User.new
-
-    respond_to do |format|
-      format.js   # new.js.rjs
-      format.xml  { render :xml => @user }
-    end
+    respond_with(@user)
   end
 
   # GET /admin/users/1/edit                                                AJAX
   #----------------------------------------------------------------------------
   def edit
-    @user = User.find(params[:id])
-
     if params[:previous].to_s =~ /(\d+)\z/
-      @previous = User.find($1)
+      @previous = User.find_by_id($1) || $1.to_i
     end
 
-  rescue ActiveRecord::RecordNotFound
-    @previous ||= $1.to_i
-    respond_to_not_found(:js) unless @user
+    respond_with(@user)
   end
 
   # POST /admin/users
@@ -80,17 +59,10 @@ class Admin::UsersController < Admin::ApplicationController
     params[:user][:password_confirmation] = nil if params[:user][:password_confirmation].blank?
     @user = User.new(params[:user])
     @user.admin = (params[:user][:admin] == "1")
+    @user.save_without_session_maintenance
+    @users = get_users
 
-    respond_to do |format|
-      if @user.save_without_session_maintenance
-        @users = get_users
-        format.js   # create.js.rjs
-        format.xml  { render :xml => @user, :status => :created, :location => @user }
-      else
-        format.js   # create.js.rjs
-        format.xml  { render :xml => @user.errors, :status => :unprocessable_entity }
-      end
-    end
+    respond_with(@user)
   end
 
   # PUT /admin/users/1
@@ -99,47 +71,27 @@ class Admin::UsersController < Admin::ApplicationController
   def update
     params[:user][:password_confirmation] = nil if params[:user][:password_confirmation].blank?
     @user = User.find(params[:id])
+    @user.update_attributes(params[:user])
     @user.admin = (params[:user][:admin] == "1")
 
-    respond_to do |format|
-      if @user.update_attributes(params[:user])
-        format.js   # update.js.rjs
-        format.xml  { head :ok }
-      else
-        format.js   # update.js.rjs
-        format.xml  { render :xml => @user.errors, :status => :unprocessable_entity }
-      end
-    end
-
-  rescue ActiveRecord::RecordNotFound
-    respond_to_not_found(:js, :xml)
+    respond_with(@user)
   end
 
   # GET /admin/users/1/confirm                                             AJAX
   #----------------------------------------------------------------------------
   def confirm
-    @user = User.find(params[:id])
-
-  rescue ActiveRecord::RecordNotFound
-    respond_to_not_found(:js, :xml)
+    respond_with(@user)
   end
 
   # DELETE /admin/users/1
   # DELETE /admin/users/1.xml                                              AJAX
   #----------------------------------------------------------------------------
   def destroy
-    @user = User.find(params[:id])
-
-    respond_to do |format|
-      if @user.destroy
-        format.js   # destroy.js.rjs
-        format.xml  { head :ok }
-      else
-        flash[:warning] = t(:msg_cant_delete_user, @user.full_name)
-        format.js   # destroy.js.rjs
-        format.xml  { render :xml => @user.errors, :status => :unprocessable_entity }
-      end
+    unless @user.destroy
+      flash[:warning] = t(:msg_cant_delete_user, @user.full_name)
     end
+
+    respond_with(@user)
   end
 
   # POST /users/auto_complete/query                                        AJAX
@@ -150,36 +102,22 @@ class Admin::UsersController < Admin::ApplicationController
   # PUT /admin/users/1/suspend.xml                                         AJAX
   #----------------------------------------------------------------------------
   def suspend
-    @user = User.find(params[:id])
     @user.update_attribute(:suspended_at, Time.now) if @user != @current_user
 
-    respond_to do |format|
-      format.js   # suspend.js.rjs
-      format.xml  { render :xml => @user }
-    end
-
-  rescue ActiveRecord::RecordNotFound
-    respond_to_not_found(:js, :xml)
+    respond_with(@user)
   end
 
   # PUT /admin/users/1/reactivate
   # PUT /admin/users/1/reactivate.xml                                      AJAX
   #----------------------------------------------------------------------------
   def reactivate
-    @user = User.find(params[:id])
     @user.update_attribute(:suspended_at, nil)
 
-    respond_to do |format|
-      format.js   # reactivate.js.rjs
-      format.xml  { render :xml => @user }
-    end
-
-  rescue ActiveRecord::RecordNotFound
-    respond_to_not_found(:js, :xml)
+    respond_with(@user)
   end
 
+private
 
-  private
   #----------------------------------------------------------------------------
   def get_users(options = {})
     self.current_page  = options[:page] if options[:page]
@@ -192,7 +130,6 @@ class Admin::UsersController < Admin::ApplicationController
     scope = User.by_id
     scope = scope.merge(@search.result)
     scope = scope.text_search(current_query)      if current_query.present?
-    scope = scope.unscoped                        if wants.csv?
     scope = scope.paginate(:page => current_page) if wants.html? || wants.js? || wants.xml?
     scope
   end

data/app/controllers/application_controller.rb

@@ -17,24 +17,47 @@
 
 class ApplicationController < ActionController::Base
 
-  helper_method :klass
-  helper_method :current_user_session, :current_user, :can_signup?
-  helper_method :called_from_index_page?, :called_from_landing_page?
-
   before_filter :set_context
   before_filter :clear_setting_cache
   before_filter "hook(:app_before_filter, self)"
   after_filter  "hook(:app_after_filter,  self)"
 
-  # See ActionController::RequestForgeryProtection for details
-  # Uncomment the :secret if you're not using the cookie session store
-  # protect_from_forgery # :secret => '165eb65bfdacf95923dad9aea10cc64a'
+  helper_method :current_user_session, :current_user, :can_signup?
+  helper_method :called_from_index_page?, :called_from_landing_page?
+  helper_method :klass
+
+  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
+
+  rescue_from ActiveRecord::RecordNotFound, :with => :respond_to_not_found
+  rescue_from CanCan::AccessDenied,         :with => :respond_to_access_denied
+
+  # 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 :partial => 'auto_complete' }
+      format.json { render :json => @auto_complete.inject({}){|h,a| h[a.id] = a.name; h } }
+    end
+  end
+
+private
 
+  #----------------------------------------------------------------------------
   def klass
     @klass ||= controller_name.classify.constantize
   end
 
-private
   #----------------------------------------------------------------------------
   def clear_setting_cache
     Setting.clear_cache!
@@ -94,11 +117,6 @@ private
     end
   end
 
-  #----------------------------------------------------------------------------
-  def get_users
-    @users ||= User.except(current_user)
-  end
-
   #----------------------------------------------------------------------------
   def store_location
     session[:return_to] = request.fullpath
@@ -129,83 +147,79 @@ private
     request.referer =~ %r(/#{controller}/\w+)
   end
 
-  #----------------------------------------------------------------------------
-  def respond_to_not_found(*types)
-    asset = self.controller_name.singularize
-    flick = case self.action_name
-      when "destroy" then "delete"
-      when "promote" then "convert"
-      else self.action_name
-    end
-    if self.action_name == "show"
-      # If asset does exist, but is not viewable to the current user..
-      if asset.capitalize.constantize.exists?(params[:id])
-        flash[:warning] = t(:msg_asset_not_authorized, asset)
-      else
-        flash[:warning] = t(:msg_asset_not_available, asset)
-      end
-    else
-      flash[:warning] = t(:msg_cant_do, :action => flick, :asset => asset)
-    end
-    respond_to do |format|
-      format.html { redirect_to :action => :index }                          if types.include?(:html)
-      format.js   { render(:update) { |page| page.reload } }                 if types.include?(:js)
-      format.json { render :text => flash[:warning], :status => :not_found } if types.include?(:json)
-      format.xml  { render :text => flash[:warning], :status => :not_found } if types.include?(:xml)
-    end
-  end
-
-  #----------------------------------------------------------------------------
-  def respond_to_related_not_found(related, *types)
-    asset = self.controller_name.singularize
-    asset = "note" if asset == "comment"
-    flash[:warning] = t(:msg_cant_create_related, :asset => asset, :related => related)
-    url = send("#{related.pluralize}_path")
-    respond_to do |format|
-      format.html { redirect_to url }                                        if types.include?(:html)
-      format.js   { render(:update) { |page| page.redirect_to url } }        if types.include?(:js)
-      format.json { render :text => flash[:warning], :status => :not_found } if types.include?(:json)
-      format.xml  { render :text => flash[:warning], :status => :not_found } if types.include?(:xml)
-    end
-  end
-
   # Proxy current page for any of the controllers by storing it in a session.
   #----------------------------------------------------------------------------
   def current_page=(page)
-    @current_page = session["#{controller_name}_current_page".to_sym] = page.to_i
+    @current_page = session[:"#{controller_name}_current_page"] = page.to_i
   end
 
   #----------------------------------------------------------------------------
   def current_page
-    page = params[:page] || session["#{controller_name}_current_page".to_sym] || 1
+    page = params[:page] || session[:"#{controller_name}_current_page"] || 1
     @current_page = page.to_i
   end
 
   # Proxy current search query for any of the controllers by storing it in a session.
   #----------------------------------------------------------------------------
   def current_query=(query)
-    @current_query = session["#{controller_name}_current_query".to_sym] = query
+    @current_query = session[:"#{controller_name}_current_query"] = query
   end
 
   #----------------------------------------------------------------------------
   def current_query
-    @current_query = params[:query] || session["#{controller_name}_current_query".to_sym] || ""
+    @current_query = params[:query] || session[:"#{controller_name}_current_query"] || ''
+  end
+
+  #----------------------------------------------------------------------------
+  def asset
+    self.controller_name.singularize
+  end
+
+  #----------------------------------------------------------------------------
+  def respond_to_not_found(*types)
+    flash[:warning] = t(:msg_asset_not_available, asset)
+
+    respond_to do |format|
+      format.html { redirect_to :action => :index }
+      format.js   { render(:update) { |page| page.reload } }
+      format.json { render :text => flash[:warning], :status => :not_found }
+      format.xml  { render :text => flash[:warning], :status => :not_found }
+    end
   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
+  def respond_to_related_not_found(related, *types)
+    asset = "note" if asset == "comment"
+    flash[:warning] = t(:msg_cant_create_related, :asset => asset, :related => related)
+
+    url = send("#{related.pluralize}_path")
+    respond_to do |format|
+      format.html { redirect_to url }
+      format.js   { render(:update) { |page| page.redirect_to url } }
+      format.json { render :text => flash[:warning], :status => :not_found }
+      format.xml  { render :text => flash[:warning], :status => :not_found }
+    end
+  end
+
+  #----------------------------------------------------------------------------
+  def respond_to_access_denied
+    if self.action_name == "show"
+      flash[:warning] = t(:msg_asset_not_authorized, asset)
+
+    else
+      flick = case self.action_name
+        when "destroy" then "delete"
+        when "promote" then "convert"
+        else self.action_name
       end
+      flash[:warning] = t(:msg_cant_do, :action => flick, :asset => asset)
+    end
+
+    respond_to do |format|
+      format.html { redirect_to :action => :index }
+      format.js   { render(:update) { |page| page.reload } }
+      format.json { render :text => flash[:warning], :status => :unauthorized }
+      format.xml  { render :text => flash[:warning], :status => :unauthorized }
     end
-    [ query.join(" "), tags.join(", ") ]
   end
 end