reduced_fat_crm 0.14.0

data/app/models/polymorphic/version.rb

@@ -0,0 +1,81 @@
+# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
+#
+# Fat Free CRM is freely distributable under the terms of MIT license.
+# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+require 'paper_trail'
+
+class Version < PaperTrail::Version
+  ASSETS = %w(all tasks campaigns leads accounts contacts opportunities comments emails)
+  EVENTS = %w(all_events create view update destroy)
+  DURATION = %w(one_hour one_day two_days one_week two_weeks one_month)
+
+  belongs_to :related, polymorphic: true
+  belongs_to :user, foreign_key: :whodunnit
+
+  scope :default_order,  lambda { order('created_at DESC') }
+  scope :include_events, lambda { |*events| where(event: events) }
+  scope :exclude_events, lambda { |*events| where('event NOT IN (?)', events) }
+  scope :for,            lambda { |user| where(whodunnit: user.id.to_s) }
+
+  class << self
+    def recent_for_user(user, limit = 10)
+      # Hybrid SQL/Ruby to build a unique list of the most recent entities that the
+      # user has interacted with
+      versions = []
+      offset = 0
+      while versions.size < limit
+        query = includes(:item)
+                .where(whodunnit: user.id.to_s)
+                .where(item_type: ENTITIES)
+                .limit(limit * 2)
+                .offset(offset)
+                .default_order
+
+        break if query.size == 0
+        versions += query.select { |v| v.item.present? }
+        versions.uniq! { |v| [v.item_id, v.item_type] }
+        offset += limit * 2
+      end
+      versions[0...10]
+    end
+
+    def latest(options = {})
+      includes(:item, :related, :user)
+        .where(({ item_type: options[:asset] } if options[:asset]))
+        .where(({ event:     options[:event] } if options[:event]))
+        .where(({ whodunnit: options[:user].to_s }  if options[:user]))
+        .where('versions.created_at >= ?', Time.zone.now - (options[:duration] || 2.days))
+        .limit(options[:max])
+        .default_order
+    end
+
+    def related_to(object)
+      where('(item_id = :id AND item_type = :type) OR (related_id = :id AND related_type = :type)',
+            id: object.id, type: object.class.name)
+    end
+
+    def history(object)
+      related_to(object).exclude_events(:view).default_order
+    end
+
+    def visible_to(user)
+      all.to_a.delete_if do |version|
+        if item = version.item || version.reify
+          if item.respond_to?(:access) # NOTE: Tasks don't have :access as of yet.
+            # Delete from scope if it shouldn't be visible
+            next item.user_id != user.id &&
+              item.assigned_to != user.id &&
+              (item.access == "Private" ||
+                (item.access == "Shared" &&
+                 !item.permissions.map(&:user_id).include?(user.id)))
+          end
+          # Don't delete any objects that don't have :access method (e.g. tasks)
+          next false
+        end
+        # Delete from scope if no object can be found or reified (e.g. from 'show' events)
+        true
+      end
+    end
+  end
+end

data/app/models/setting.rb

@@ -0,0 +1,103 @@
+# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
+#
+# Fat Free CRM is freely distributable under the terms of MIT license.
+# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+# == Schema Information
+#
+# Table name: settings
+#
+#  id            :integer         not null, primary key
+#  name          :string(32)      default(""), not null
+#  value         :text
+#  created_at    :datetime
+#  updated_at    :datetime
+#
+
+# Fat Free CRM settings are stored in three places, and are loaded in the following order:
+#
+# 1) config/settings.default.yml
+# 2) config/settings.yml  (if exists)
+# 3) 'settings' table in database  (if exists)
+#
+# Any configured settings in `config/settings.yml` will override those in
+# `config/settings.default.yml`, and settings in the database table have the highest priority.
+
+class Setting < ActiveRecord::Base
+  serialize :value
+
+  # Use class variables for cache and yaml settings.
+  cattr_accessor :cache, :yaml_settings
+  @@cache = @@yaml_settings = {}.with_indifferent_access
+
+  class << self
+    # Cache should be cleared before each request.
+    def clear_cache!
+      @@cache = {}.with_indifferent_access
+    end
+
+    #-------------------------------------------------------------------
+    def method_missing(method, *args)
+      super
+    rescue NoMethodError
+      method_name = method.to_s
+      if method_name.last == "="
+        self[method_name.sub("=", "")] = args.first
+      else
+        self[method_name]
+      end
+    end
+
+    # Get setting value (from database or loaded YAML files)
+    #-------------------------------------------------------------------
+    def [](name)
+      # Return value if cached
+      return cache[name] if cache.key?(name)
+      # Check database
+      if database_and_table_exists?
+        if setting = find_by_name(name.to_s)
+          unless setting.value.nil?
+            return cache[name] = setting.value
+          end
+        end
+      end
+      # Check YAML settings
+      if yaml_settings.key?(name)
+        return cache[name] = yaml_settings[name]
+      end
+    end
+
+    # Set setting value
+    #-------------------------------------------------------------------
+    def []=(name, value)
+      return nil unless database_and_table_exists?
+      setting = find_by_name(name.to_s) || new(name: name)
+      setting.value = value
+      setting.save
+      cache[name] = value
+    end
+
+    # Unrolls [ :one, :two ] settings array into [[ "One", :one ], [ "Two", :two ]]
+    # picking symbol translations from locale. If setting is not a symbol but
+    # string it gets copied without translation.
+    #-------------------------------------------------------------------
+    def unroll(setting)
+      send(setting).map { |key| [key.is_a?(Symbol) ? I18n.t(key) : key, key.to_sym] }
+    end
+
+    def database_and_table_exists?
+      # Returns false if table or database is unavailable.
+      # Catches all database-related errors, so that Setting will return nil
+      # instead of crashing the entire application.
+      table_exists? rescue false
+    end
+
+    # Loads settings from YAML files
+    def load_settings_from_yaml(file)
+      settings = YAML.load(ERB.new(File.read(file)).result)
+      @@yaml_settings.deep_merge!(settings)
+    end
+  end
+
+  ActiveSupport.run_load_hooks(:fat_free_crm_setting, self)
+end

data/app/models/users/ability.rb

@@ -0,0 +1,59 @@
+# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
+#
+# Fat Free CRM is freely distributable under the terms of MIT license.
+# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+# See the wiki for details: https://github.com/ryanb/cancan/wiki/Defining-Abilities
+
+class Ability
+  include CanCan::Ability
+
+  def initialize(user)
+    # handle signup
+    can(:create, User) if User.can_signup?
+
+    if user.present?
+      entities = [Account, Campaign, Contact, Lead, Opportunity]
+
+      # User
+      can :manage, User, id: user.id # can do any action on themselves
+
+      # Tasks
+      can :create, Task
+      can :manage, Task, user: user.id
+      can :manage, Task, assigned_to: user.id
+      can :manage, Task, completed_by: user.id
+
+      # Entities
+      can :manage, entities, access: 'Public'
+      can :manage, entities + [Task], user_id: user.id
+      can :manage, entities + [Task], assigned_to: user.id
+
+      #
+      # Due to an obscure bug (see https://github.com/ryanb/cancan/issues/213)
+      # we must switch on user.admin? here to avoid the nil constraints which
+      # activate the issue referred to above.
+      #
+      if user.admin?
+        can :manage, :all
+      else
+        # Group or User permissions
+        t = Permission.arel_table
+        scope = t[:user_id].eq(user.id)
+
+        if (group_ids = user.group_ids).any?
+          scope = scope.or(t[:group_id].eq_any(group_ids))
+        end
+
+        entities.each do |klass|
+          if (asset_ids = Permission.where(scope.and(t[:asset_type].eq(klass.name))).pluck(:asset_id)).any?
+            can :manage, klass, id: asset_ids
+          end
+        end
+      end # if user.admin?
+
+    end
+  end
+
+  ActiveSupport.run_load_hooks(:fat_free_crm_ability, self)
+end

data/app/models/users/authentication.rb

@@ -0,0 +1,54 @@
+# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
+#
+# Fat Free CRM is freely distributable under the terms of MIT license.
+# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+class Authentication < Authlogic::Session::Base # NOTE: This is not ActiveRecord model.
+  authenticate_with User
+  after_save :check_if_suspended
+  single_access_allowed_request_types :any
+
+  def to_key
+    id ? id : nil
+  end
+
+  private
+
+  # Override Authlogic's validate_by_password() to allow blank passwords. See
+  # authlogic/lib/authlogic/session/password.rb for details.
+  #----------------------------------------------------------------------------
+  def validate_by_password
+    self.invalid_password = false
+
+    self.attempted_record = search_for_record(find_by_login_method, send(login_field))
+    if attempted_record.blank?
+      generalize_credentials_error_messages? ?
+        add_general_credentials_error :
+        errors.add(login_field, I18n.t('error_messages.login_not_found', default: "is not valid"))
+      return
+    end
+
+    unless attempted_record.send(verify_password_method, send("protected_#{password_field}"))
+      self.invalid_password = true
+      generalize_credentials_error_messages? ?
+        add_general_credentials_error :
+        errors.add(password_field, I18n.t('error_messages.password_invalid', default: "is not valid"))
+      return
+    end
+  end
+
+  # Override Authologic instance method in order to keep :login_count,
+  # :last_login_at, and :last_login_ip intact if the user is suspended.
+  # See vendor/plugin/authlogin/lib/authlogic/session/magic_columns.rb.
+  #----------------------------------------------------------------------------
+  def update_info
+    super unless user.suspended?
+  end
+
+  #----------------------------------------------------------------------------
+  def check_if_suspended
+    errors.add(:base, I18n.t(:msg_account_suspended)) if user.suspended?
+  end
+
+  ActiveSupport.run_load_hooks(:fat_free_crm_authentication, self)
+end

data/app/models/users/group.rb

@@ -0,0 +1,13 @@
+# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
+#
+# Fat Free CRM is freely distributable under the terms of MIT license.
+# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+class Group < ActiveRecord::Base
+  has_and_belongs_to_many :users
+  has_many :permissions
+
+  validates :name, presence: true, uniqueness: true
+
+  ActiveSupport.run_load_hooks(:fat_free_crm_group, self)
+end

data/app/models/users/permission.rb

@@ -0,0 +1,27 @@
+# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
+#
+# Fat Free CRM is freely distributable under the terms of MIT license.
+# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+# == Schema Information
+#
+# Table name: permissions
+#
+#  id         :integer         not null, primary key
+#  user_id    :integer
+#  asset_id   :integer
+#  asset_type :string(255)
+#  created_at :datetime
+#  updated_at :datetime
+#
+
+class Permission < ActiveRecord::Base
+  belongs_to :user
+  belongs_to :group
+  belongs_to :asset, polymorphic: true
+
+  validates_presence_of :user_id, unless: :group_id?
+  validates_presence_of :group_id, unless: :user_id?
+
+  ActiveSupport.run_load_hooks(:fat_free_crm_permission, self)
+end

data/app/models/users/preference.rb

@@ -0,0 +1,50 @@
+# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
+#
+# Fat Free CRM is freely distributable under the terms of MIT license.
+# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+# == Schema Information
+#
+# Table name: preferences
+#
+#  id         :integer         not null, primary key
+#  user_id    :integer
+#  name       :string(32)      default(""), not null
+#  value      :text
+#  created_at :datetime
+#  updated_at :datetime
+#
+
+class Preference < ActiveRecord::Base
+  belongs_to :user
+
+  #-------------------------------------------------------------------
+  def [](name)
+    # Following line is to preserve AR relationships
+    return super(name) if name.to_s == "user_id" # get the value of belongs_to
+
+    return cached_prefs[name.to_s] if cached_prefs.key?(name.to_s)
+    cached_prefs[name.to_s] = if user.present? && pref = Preference.find_by_name_and_user_id(name.to_s, user.id)
+                                Marshal.load(Base64.decode64(pref.value))
+    end
+  end
+
+  #-------------------------------------------------------------------
+  def []=(name, value)
+    return super(name, value) if name.to_s == "user_id" # set the value of belongs_to
+
+    encoded = Base64.encode64(Marshal.dump(value))
+    if pref = Preference.find_by(name: name.to_s, user_id: user.id)
+      pref.update_attribute(:value, encoded)
+    else
+      Preference.create(user: user, name: name.to_s, value: encoded)
+    end
+    cached_prefs[name.to_s] = value
+  end
+
+  def cached_prefs
+    @cached_prefs ||= {}
+  end
+
+  ActiveSupport.run_load_hooks(:fat_free_crm_preference, self)
+end

data/app/models/users/user.rb

@@ -0,0 +1,184 @@
+# Copyright (c) 2008-2013 Michael Dvorkin and contributors.
+#
+# Fat Free CRM is freely distributable under the terms of MIT license.
+# See MIT-LICENSE file or http://www.opensource.org/licenses/mit-license.php
+#------------------------------------------------------------------------------
+# == Schema Information
+#
+# Table name: users
+#
+#  id                  :integer         not null, primary key
+#  username            :string(32)      default(""), not null
+#  email               :string(64)      default(""), not null
+#  first_name          :string(32)
+#  last_name           :string(32)
+#  title               :string(64)
+#  company             :string(64)
+#  alt_email           :string(64)
+#  phone               :string(32)
+#  mobile              :string(32)
+#  aim                 :string(32)
+#  yahoo               :string(32)
+#  google              :string(32)
+#  skype               :string(32)
+#  password_hash       :string(255)     default(""), not null
+#  password_salt       :string(255)     default(""), not null
+#  persistence_token   :string(255)     default(""), not null
+#  perishable_token    :string(255)     default(""), not null
+#  last_login_at       :datetime
+#  current_login_at    :datetime
+#  last_login_ip       :string(255)
+#  current_login_ip    :string(255)
+#  login_count         :integer         default(0), not null
+#  deleted_at          :datetime
+#  created_at          :datetime
+#  updated_at          :datetime
+#  admin               :boolean         default(FALSE), not null
+#  suspended_at        :datetime
+#  single_access_token :string(255)
+#
+
+class User < ActiveRecord::Base
+  before_create :check_if_needs_approval
+  before_destroy :check_if_current_user, :check_if_has_related_assets
+
+  has_one :avatar, as: :entity, dependent: :destroy  # Personal avatar.
+  has_many :avatars                                         # As owner who uploaded it, ex. Contact avatar.
+  has_many :comments, as: :commentable                   # As owner who created a comment.
+  has_many :accounts
+  has_many :campaigns
+  has_many :leads
+  has_many :contacts
+  has_many :opportunities
+  has_many :assigned_opportunities, class_name: 'Opportunity', foreign_key: 'assigned_to'
+  has_many :permissions, dependent: :destroy
+  has_many :preferences, dependent: :destroy
+  has_many :lists
+  has_and_belongs_to_many :groups
+
+  has_paper_trail class_name: 'Version', ignore: [:perishable_token]
+
+  scope :by_id, -> { order('id DESC') }
+  scope :without, ->(user) { where('id != ?', user.id).by_name }
+  scope :by_name, -> { order('first_name, last_name, email') }
+
+  scope :text_search, ->(query) {
+    query = query.gsub(/[^\w\s\-\.'\p{L}]/u, '').strip
+    where('upper(username) LIKE upper(:s) OR upper(email) LIKE upper(:s) OR upper(first_name) LIKE upper(:s) OR upper(last_name) LIKE upper(:s)', s: "%#{query}%")
+  }
+
+  scope :my, -> { accessible_by(User.current_ability) }
+
+  scope :have_assigned_opportunities, -> {
+    joins("INNER JOIN opportunities ON users.id = opportunities.assigned_to")
+      .where("opportunities.stage <> 'lost' AND opportunities.stage <> 'won'")
+      .select('DISTINCT(users.id), users.*')
+  }
+
+  acts_as_authentic do |c|
+    c.session_class = Authentication
+    c.validates_uniqueness_of_login_field_options = { case_sensitive: false, message: :username_taken }
+    c.validates_length_of_login_field_options     = { minimum: 1, message: :missing_username }
+    c.validates_uniqueness_of_email_field_options = { message: :email_in_use }
+    c.validates_length_of_password_field_options  = { minimum: 0, allow_blank: true, if: :require_password? }
+    c.ignore_blank_passwords = true
+    c.crypto_provider = Authlogic::CryptoProviders::Sha512
+  end
+
+  # Store current user in the class so we could access it from the activity
+  # observer without extra authentication query.
+  cattr_accessor :current_user
+
+  validates_presence_of :email, message: :missing_email
+
+  #----------------------------------------------------------------------------
+  def name
+    first_name.blank? ? username : first_name
+  end
+
+  #----------------------------------------------------------------------------
+  def full_name
+    first_name.blank? && last_name.blank? ? email : "#{first_name} #{last_name}".strip
+  end
+
+  #----------------------------------------------------------------------------
+  def suspended?
+    suspended_at != nil
+  end
+
+  #----------------------------------------------------------------------------
+  def awaits_approval?
+    self.suspended? && login_count == 0 && Setting.user_signup == :needs_approval
+  end
+
+  #----------------------------------------------------------------------------
+  def preference
+    @preference ||= preferences.build
+  end
+  alias_method :pref, :preference
+
+  #----------------------------------------------------------------------------
+  def deliver_password_reset_instructions!
+    reset_perishable_token!
+    UserMailer.password_reset_instructions(self).deliver_now
+  end
+
+  # Override global I18n.locale if the user has individual local preference.
+  #----------------------------------------------------------------------------
+  def set_individual_locale
+    I18n.locale = preference[:locale] if preference[:locale]
+  end
+
+  # Generate the value of single access token if it hasn't been set already.
+  #----------------------------------------------------------------------------
+  def set_single_access_token
+    self.single_access_token ||= update_attribute(:single_access_token, Authlogic::Random.friendly_token)
+  end
+
+  def to_json(_options = nil)
+    [name].to_json
+  end
+
+  def to_xml(_options = nil)
+    [name].to_xml
+  end
+
+  private
+
+  # Suspend newly created user if signup requires an approval.
+  #----------------------------------------------------------------------------
+  def check_if_needs_approval
+    self.suspended_at = Time.now if Setting.user_signup == :needs_approval && !admin
+  end
+
+  # Prevent current user from deleting herself.
+  #----------------------------------------------------------------------------
+  def check_if_current_user
+    User.current_user.nil? || User.current_user != self
+  end
+
+  # Prevent deleting a user unless she has no artifacts left.
+  #----------------------------------------------------------------------------
+  def check_if_has_related_assets
+    artifacts = %w(Account Campaign Lead Contact Opportunity Comment Task).inject(0) do |sum, asset|
+      klass = asset.constantize
+      sum += klass.assigned_to(self).count if asset != "Comment"
+      sum += klass.created_by(self).count
+    end
+    artifacts == 0
+  end
+
+  # Define class methods
+  #----------------------------------------------------------------------------
+  class << self
+    def current_ability
+      Ability.new(User.current_user)
+    end
+
+    def can_signup?
+      [:allowed, :needs_approval].include? Setting.user_signup
+    end
+  end
+
+  ActiveSupport.run_load_hooks(:fat_free_crm_user, self)
+end