fat_free_crm 0.12.3 → 0.13.0

data/app/assets/stylesheets/header.scss

@@ -76,6 +76,9 @@ $color_footer: grey;
   padding: 0px;
   text-align: center;
   width: 100%;
+  i.fa { 
+    font-size: 130%; 
+    vertical-align:text-top; }
   ul {
     // :margin 0px 25%,  18% for 5th tab
     margin-left: 15px; }

data/app/assets/stylesheets/lists.css.scss

@@ -6,3 +6,7 @@
 // Place all the styles related to the Lists controller here.
 // They will automatically be included in application.css.
 // You can use Sass (SCSS) here: http://sass-lang.com/
+#lists, #personal_lists {
+	i.fa {font-size: 130%}
+	a:hover {background:none; color:#0033cc}
+}

data/app/controllers/admin/fields_controller.rb

@@ -33,7 +33,7 @@ class Admin::FieldsController < Admin::ApplicationController
   #----------------------------------------------------------------------------
   def edit
     @field = Field.find(params[:id])
-    respond_with(@field)    
+    respond_with(@field)
   end
 
   # POST /fields
@@ -41,7 +41,7 @@ class Admin::FieldsController < Admin::ApplicationController
   #----------------------------------------------------------------------------
   def create
     as = params[:field][:as]
-    @field = 
+    @field =
       if as =~ /pair/
         CustomFieldPair.create_pair(params).first
       elsif as.present?
@@ -91,7 +91,7 @@ class Admin::FieldsController < Admin::ApplicationController
 
     render :nothing => true
   end
-  
+
   # GET /fields/subform
   #----------------------------------------------------------------------------
   def subform
@@ -108,7 +108,7 @@ class Admin::FieldsController < Admin::ApplicationController
 
     respond_with(@field) do |format|
       format.html { render :partial => 'admin/fields/subform' }
-    end  
+    end
   end
-  
+
 end

data/app/controllers/admin/users_controller.rb

@@ -77,9 +77,7 @@ class Admin::UsersController < Admin::ApplicationController
   # DELETE /admin/users/1.xml                                              AJAX
   #----------------------------------------------------------------------------
   def destroy
-    unless @user.destroy
-      flash[:warning] = t(:msg_cant_delete_user, @user.full_name)
-    end
+    flash[:warning] = t(:msg_cant_delete_user, @user.full_name) unless @user.destroy
 
     respond_with(@user)
   end

data/app/controllers/application_controller.rb

@@ -145,7 +145,7 @@ private
 
   #----------------------------------------------------------------------------
   def can_signup?
-    User.can_signup?
+    [ :allowed, :needs_approval ].include? Setting.user_signup
   end
 
   #----------------------------------------------------------------------------
@@ -199,10 +199,10 @@ private
     flash[:warning] = t(:msg_asset_not_available, asset)
 
     respond_to do |format|
-      format.html { redirect_to(redirection_url) }
+      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 :xml => [flash[:warning]], :status => :not_found }
+      format.json { render :text => flash[:warning], :status => :not_found }
+      format.xml  { render :text => flash[:warning], :status => :not_found }
     end
   end
 
@@ -213,32 +213,32 @@ private
 
     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 :xml => [flash[:warning]], :status => :not_found }
+      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
-    flash[:warning] = t(:msg_not_authorized, default: 'You are not authorized to take this action.')
-    respond_to do |format|
-      format.html { redirect_to(redirection_url) }
-      format.js   { render(:update) { |page| page.reload } }
-      format.json { render :text => flash[:warning],  :status => :unauthorized }
-      format.xml  { render :xml => [flash[:warning]], :status => :unauthorized }
-    end
-  end
+    if self.action_name == "show"
+      flash[:warning] = t(:msg_asset_not_authorized, asset)
 
-  #----------------------------------------------------------------------------
-  def redirection_url
-    # Try to redirect somewhere sensible. Note: not all controllers have an index action
-    url = if current_user.present?
-      (respond_to?(:index) and self.action_name != 'index') ? { action: 'index' } : root_url
     else
-      login_url
+      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
-  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
+  end
 end

data/app/controllers/comments_controller.rb

@@ -6,8 +6,6 @@
 class CommentsController < ApplicationController
   before_filter :require_user
 
-
-
   # GET /comments
   # GET /comments.json
   # GET /comments.xml
@@ -31,24 +29,6 @@ class CommentsController < ApplicationController
     end
   end
 
-  # GET /comments/new
-  # GET /comments/new.json
-  # GET /comments/new.xml                                                  AJAX
-  #----------------------------------------------------------------------------
-  def new
-    @comment = Comment.new
-    @commentable = extract_commentable_name(params)
-
-    if @commentable
-      update_commentable_session
-      unless @commentable.classify.constantize.my.find_by_id(params[:"#{@commentable}_id"])
-        respond_to_related_not_found(@commentable) and return
-      end
-    end
-
-    respond_with(@comment)
-  end
-
   # GET /comments/1/edit                                                   AJAX
   #----------------------------------------------------------------------------
   def edit
@@ -73,10 +53,10 @@ class CommentsController < ApplicationController
     model, id = @comment.commentable_type, @comment.commentable_id
     unless model.constantize.my.find_by_id(id)
       respond_to_related_not_found(model.downcase)
+    else
+      @comment.save
+      respond_with(@comment)
     end
-
-    @comment.save
-    respond_with(@comment)
   end
 
   # PUT /comments/1
@@ -106,12 +86,4 @@ private
     params.keys.detect {|x| x =~ /_id$/ }.try(:sub, /_id$/, '')
   end
 
-  #----------------------------------------------------------------------------
-  def update_commentable_session
-    if params[:cancel].true?
-      session.delete("#{@commentable}_new_comment")
-    else
-      session["#{@commentable}_new_comment"] = true
-    end
-  end
 end

data/app/controllers/entities/accounts_controller.rb

@@ -105,7 +105,7 @@ class AccountsController < EntitiesController
     current_user.pref[:accounts_sort_by]  = Account::sort_by_map[params[:sort_by]] if params[:sort_by]
     @accounts = get_accounts(:page => 1, :per_page => params[:per_page])
     set_options # Refresh options
-    
+
     respond_with(@accounts) do |format|
       format.js { render :index }
     end
@@ -116,7 +116,7 @@ class AccountsController < EntitiesController
   def filter
     session[:accounts_filter] = params[:category]
     @accounts = get_accounts(:page => 1, :per_page => params[:per_page])
-    
+
     respond_with(@accounts) do |format|
       format.js { render :index }
     end
@@ -136,7 +136,7 @@ private
         @accounts = get_accounts(:page => current_page - 1) if current_page > 1
         render :index and return
       end
-      # At this point render default destroy.js.rjs template.
+      # At this point render default destroy.js
     else # :html request
       self.current_page = 1 # Reset current page to 1 to make sure it stays valid.
       flash[:notice] = t(:msg_asset_deleted, @account.name)

data/app/controllers/entities/campaigns_controller.rb

@@ -32,7 +32,7 @@ class CampaignsController < EntitiesController
         @comment = Comment.new
         @timeline = timeline(@campaign)
       end
-      
+
       format.js do
         @stage = Setting.unroll(:opportunity_stage)
         @comment = Comment.new
@@ -143,7 +143,7 @@ class CampaignsController < EntitiesController
     current_user.pref[:campaigns_sort_by]  = Campaign::sort_by_map[params[:sort_by]] if params[:sort_by]
     @campaigns = get_campaigns(:page => 1, :per_page => params[:per_page])
     set_options # Refresh options
-    
+
     respond_with(@campaigns) do |format|
       format.js { render :index }
     end
@@ -154,7 +154,7 @@ class CampaignsController < EntitiesController
   def filter
     session[:campaigns_filter] = params[:status]
     @campaigns = get_campaigns(:page => 1, :per_page => params[:per_page])
-    
+
     respond_with(@campaigns) do |format|
       format.js { render :index }
     end
@@ -174,7 +174,7 @@ private
         @campaigns = get_campaigns(:page => current_page - 1) if current_page > 1
         render :index and return
       end
-      # At this point render destroy.js.rjs
+      # At this point render destroy.js
     else # :html request
       self.current_page = 1
       flash[:notice] = t(:msg_asset_deleted, @campaign.name)

data/app/controllers/entities/contacts_controller.rb

@@ -135,7 +135,7 @@ class ContactsController < EntitiesController
 
     @contacts = get_contacts(:page => 1, :per_page => params[:per_page]) # Start on the first page.
     set_options # Refresh options
-    
+
     respond_with(@contacts) do |format|
       format.js { render :index }
     end
@@ -167,7 +167,7 @@ class ContactsController < EntitiesController
       else
         self.current_page = 1
       end
-      # At this point render destroy.js.rjs
+      # At this point render destroy.js
     else
       self.current_page = 1
       flash[:notice] = t(:msg_asset_deleted, @contact.full_name)

data/app/controllers/entities/leads_controller.rb

@@ -176,7 +176,7 @@ class LeadsController < EntitiesController
 
     @leads = get_leads(:page => 1, :per_page => params[:per_page]) # Start one the first page.
     set_options # Refresh options
-    
+
     respond_with(@leads) do |format|
       format.js { render :index }
     end
@@ -187,7 +187,7 @@ class LeadsController < EntitiesController
   def filter
     session[:leads_filter] = params[:status]
     @leads = get_leads(:page => 1, :per_page => params[:per_page]) # Start one the first page.
-    
+
     respond_with(@leads) do |format|
       format.js { render :index }
     end
@@ -221,7 +221,7 @@ private
       else                                        # Called from related asset.
         self.current_page = 1                     # Reset current page to 1 to make sure it stays valid.
         @campaign = @lead.campaign                # Reload lead's campaign if any.
-      end                                         # Render destroy.js.rjs
+      end                                         # Render destroy.js
     else # :html destroy
       self.current_page = 1
       flash[:notice] = t(:msg_asset_deleted, @lead.full_name)

data/app/controllers/entities/opportunities_controller.rb

@@ -39,7 +39,8 @@ class OpportunitiesController < EntitiesController
       model, id = params[:related].split('_')
       if related = model.classify.constantize.my.find_by_id(id)
         instance_variable_set("@#{model}", related)
-        @account = related.account if related.respond_to?(:account)
+        @account = related.account if related.respond_to?(:account) && !related.account.nil?
+        @campaign = related.campaign if related.respond_to?(:campaign)
       else
         respond_to_related_not_found(model) and return
       end
@@ -149,7 +150,7 @@ class OpportunitiesController < EntitiesController
   def redraw
     @opportunities = get_opportunities(:page => 1, :per_page => params[:per_page])
     set_options # Refresh options
-    
+
     respond_with(@opportunities) do |format|
       format.js { render :index }
     end
@@ -182,7 +183,7 @@ private
       else # Called from related asset.
         self.current_page = 1
       end
-      # At this point render destroy.js.rjs
+      # At this point render destroy.js
     else
       self.current_page = 1
       flash[:notice] = t(:msg_asset_deleted, @opportunity.name)

data/app/controllers/entities_controller.rb

@@ -7,7 +7,7 @@ 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
 
@@ -43,8 +43,8 @@ class EntitiesController < ApplicationController
     entity.subscribed_users += [current_user.id]
     entity.save
 
-    respond_with(entity) do |format|
-      format.js { render 'subscription_update' }
+    respond_with(@entity) do |format|
+      format.js { render 'subscription_update', :entity => entity }
     end
   end
 
@@ -55,7 +55,7 @@ class EntitiesController < ApplicationController
     entity.save
 
     respond_with(entity) do |format|
-      format.js { render 'subscription_update' }
+      format.js { render 'subscription_update', :entity => entity }
     end
   end
 
@@ -111,7 +111,7 @@ protected
   def entities
     instance_variable_get("@#{controller_name}") || klass.my
   end
-  
+
   def set_options
     unless params[:cancel].true?
       klass = controller_name.classify.constantize
@@ -167,7 +167,7 @@ private
       end
       scope = scope.paginate(:page => current_page, :per_page => per_page)
     end
-    
+
     scope
   end
 

data/app/controllers/home_controller.rb

@@ -6,6 +6,7 @@
 class HomeController < ApplicationController
   before_filter :require_user, :except => [ :toggle, :timezone ]
   before_filter :set_current_tab, :only => :index
+  before_filter "hook(:home_before_filter, self, :amazing => true)"
 
   #----------------------------------------------------------------------------
   def index
@@ -39,7 +40,6 @@ class HomeController < ApplicationController
     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
   end
 

data/app/controllers/lists_controller.rb

@@ -8,8 +8,15 @@ class ListsController < ApplicationController
   # POST /lists
   #----------------------------------------------------------------------------
   def create
+
+    if params[:is_global].to_i.zero?
+      params[:list][:user_id] = current_user.id
+    else
+      params[:list][:user_id] = nil
+    end
+
     # Find any existing list with the same name (case insensitive)
-    if @list = List.find(:first, :conditions => ["lower(name) = ?", params[:list][:name].downcase])
+    if @list = List.where("lower(name) = ?", params[:list][:name].downcase).where({:user_id => params[:list][:user_id]}).first
       @list.update_attributes(params[:list])
     else
       @list = List.create(params[:list])

data/app/controllers/tasks_controller.rb

@@ -83,7 +83,7 @@ class TasksController < ApplicationController
   def update
     @view = params[:view] || "pending"
     @task = Task.tracked_by(current_user).find(params[:id])
-    @task_before_update = @task.clone
+    @task_before_update = @task.dup
 
     if @task.due_at && (@task.due_at < Date.today.to_time)
       @task_before_update.bucket = "overdue"

data/app/controllers/users_controller.rb

@@ -5,30 +5,44 @@
 #------------------------------------------------------------------------------
 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, :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, :edit, :update ]
 
-  check_authorization
-  load_and_authorize_resource # handles all security
+  load_resource
 
   respond_to :html, :only => [ :show, :new ]
 
   # GET /users/1
-  # GET /users/1.js
+  # GET /users/1.json
+  # GET /users/1.xml                                                       HTML
   #----------------------------------------------------------------------------
   def show
-    @user = current_user if params[:id].nil?
     respond_with(@user)
   end
 
   # GET /users/new
-  # GET /users/new.js
+  # GET /users/new.json
+  # GET /users/new.xml                                                     HTML
   #----------------------------------------------------------------------------
   def new
+    if can_signup?
+      respond_with(@user)
+    else
+      redirect_to login_path
+    end
+  end
+
+  # GET /users/1/edit                                                      AJAX
+  #----------------------------------------------------------------------------
+  def edit
     respond_with(@user)
   end
 
   # POST /users
-  # POST /users.js
+  # POST /users.xml                                                        HTML
   #----------------------------------------------------------------------------
   def create
     if @user.save
@@ -44,29 +58,31 @@ class UsersController < ApplicationController
     end
   end
 
-  # GET /users/1/edit.js
-  #----------------------------------------------------------------------------
-  def edit
-    respond_with(@user)
-  end
-
   # PUT /users/1
-  # PUT /users/1.js
+  # PUT /users/1.json
+  # PUT /users/1.xml                                                       AJAX
   #----------------------------------------------------------------------------
   def update
     @user.update_attributes(params[:user])
     respond_with(@user)
   end
 
+  # DELETE /users/1
+  # DELETE /users/1.xml                HTML and AJAX (not directly exposed yet)
+  #----------------------------------------------------------------------------
+  def destroy
+    # not exposed
+  end
+
   # GET /users/1/avatar
-  # GET /users/1/avatar.js
+  # GET /users/1/avatar.xml                                                AJAX
   #----------------------------------------------------------------------------
   def avatar
     respond_with(@user)
   end
 
   # PUT /users/1/upload_avatar
-  # PUT /users/1/upload_avatar.js
+  # PUT /users/1/upload_avatar.xml                                         AJAX
   #----------------------------------------------------------------------------
   def upload_avatar
     if params[:gravatar]
@@ -90,21 +106,19 @@ class UsersController < ApplicationController
   end
 
   # GET /users/1/password
-  # GET /users/1/password.js
+  # GET /users/1/password.xml                                              AJAX
   #----------------------------------------------------------------------------
   def password
     respond_with(@user)
   end
 
   # PUT /users/1/change_password
-  # PUT /users/1/change_password.js
+  # PUT /users/1/change_password.xml                                       AJAX
   #----------------------------------------------------------------------------
   def change_password
     if @user.valid_password?(params[:current_password], true) || @user.password_hash.blank?
       unless params[:user][:password].blank?
-        @user.password = params[:user][:password]
-        @user.password_confirmation = params[:user][:password_confirmation]
-        @user.save
+        @user.update_attributes(params[:user])
         flash[:notice] = t(:msg_password_changed)
       else
         flash[:notice] = t(:msg_password_not_changed)
@@ -116,18 +130,27 @@ class UsersController < ApplicationController
     respond_with(@user)
   end
 
-  # POST /users/1/redraw
+  # POST /users/1/redraw                                                   AJAX
   #----------------------------------------------------------------------------
   def redraw
     current_user.preference[:locale] = params[:locale]
     render(:update) { |page| page.redirect_to user_path(current_user) }
   end
 
-  # GET /users/opportunities_overview
-  #----------------------------------------------------------------------------
   def opportunities_overview
     @users_with_opportunities = User.have_assigned_opportunities.order(:first_name)
     @unassigned_opportunities = Opportunity.unassigned.pipeline.order(:stage)
   end
 
+  private
+
+  #----------------------------------------------------------------------------
+  def require_and_assign_user
+    require_user
+    @user = current_user
+  end
+
+  def assign_given_or_current_user
+    @user = params[:id] ? User.find(params[:id]) : current_user
+  end
 end