fat_free_crm 0.11.3 → 0.11.4

data/app/models/fields/custom_field_date_pair.rb

@@ -0,0 +1,58 @@
+# Fat Free CRM
+# Copyright (C) 2008-2011 by Michael Dvorkin
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#------------------------------------------------------------------------------
+
+class CustomFieldDatePair < CustomFieldPair
+
+  # Register this CustomField with the application
+  #------------------------------------------------------------------------------
+  register(:as => 'date_pair', :klass => 'CustomFieldDatePair', :type => 'date')
+
+  # For rendering paired values
+  # Handle case where both pairs are blank
+  #------------------------------------------------------------------------------
+  def render_value(object)
+    return "" unless paired_with.present?
+    from = render(object.send(name))
+    to = render(object.send(paired_with.name))
+    if from.present? and to.present?
+      I18n.t('pair.from_to', :from => from, :to => to)
+    elsif from.present? and !to.present?
+      I18n.t('pair.from_only', :from => from)
+    elsif !from.present? and to.present?
+      I18n.t('pair.to_only', :to => to)
+    else
+      ""
+    end
+  end
+  
+  def render(value)
+    value && value.strftime(I18n.t("date.formats.mmddyy"))
+  end
+  
+  def custom_validator(obj)
+    super
+    # validate when we get to 2nd of the pair
+    if pair_id.present?
+      start = CustomFieldPair.find(pair_id)
+      return if start.nil?
+      from = obj.send(start.name)
+      to = obj.send(name)
+      obj.errors.add(name.to_sym, ::I18n.t('activerecord.errors.models.custom_field.endbeforestart', :field => start.label)) if from.present? and to.present? and (from > to)
+    end
+  end
+
+end

data/app/models/fields/custom_field_datetime_pair.rb

@@ -0,0 +1,28 @@
+# Fat Free CRM
+# Copyright (C) 2008-2011 by Michael Dvorkin
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#------------------------------------------------------------------------------
+
+class CustomFieldDatetimePair < CustomFieldDatePair
+
+  # Register this CustomField with the application
+  #------------------------------------------------------------------------------
+  register(:as => 'datetime_pair', :klass => 'CustomFieldDatetimePair', :type => 'timestamp')
+
+  def render(value)
+    value && value.strftime(I18n.t("time.formats.mmddhhss"))
+  end
+
+end

data/app/models/fields/custom_field_pair.rb

@@ -0,0 +1,54 @@
+# Fat Free CRM
+# Copyright (C) 2008-2011 by Michael Dvorkin
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#------------------------------------------------------------------------------
+
+class CustomFieldPair < CustomField
+
+  has_one :pair, :class_name => CustomFieldPair, :foreign_key => 'pair_id', :dependent => :destroy # points to 'end'
+
+  # Helper to create a pair. Used in fields_controller
+  #------------------------------------------------------------------------------
+  def self.create_pair(params)
+    fields = params['field']
+    as = params['field']['as']
+    pair = params.delete('pair')
+    base_params = fields.delete_if{|k,v| !%w(field_group_id label as).include?(k)}
+    klass = ("custom_field_" + as.gsub('pair', '_pair')).classify.constantize
+    field1 = klass.create( base_params.merge(pair['0']) )
+    field2 = klass.create( base_params.merge(pair['1']).merge('pair_id' => field1.id, 'required' => field1.required, 'disabled' => field1.disabled) )
+    [field1, field2]
+  end
+  
+  # Helper to update a pair. Used in fields_controller
+  #------------------------------------------------------------------------------
+  def self.update_pair(params)
+    fields = params['field']
+    pair = params.delete('pair')
+    base_params = fields.delete_if{|k,v| !%w(field_group_id label as).include?(k)}
+    field1 = CustomFieldPair.find(params['id'])
+    field1.update_attributes( base_params.merge(pair['0']) )
+    field2 = field1.paired_with
+    field2.update_attributes( base_params.merge(pair['1']).merge('required' => field1.required, 'disabled' => field1.disabled) )
+    [field1, field2]
+  end
+
+  # Returns the field that this field is paired with
+  #------------------------------------------------------------------------------
+  def paired_with
+    pair || CustomFieldPair.where(:pair_id => id).first
+  end
+
+end

data/app/models/fields/field.rb

@@ -23,6 +23,7 @@
 #  type           :string(255)
 #  field_group_id :integer
 #  position       :integer
+#  pair_id        :integer
 #  name           :string(64)
 #  label          :string(128)
 #  hint           :string(255)
@@ -40,58 +41,48 @@ class Field < ActiveRecord::Base
   acts_as_list
 
   serialize :collection, Array
+  serialize :settings, HashWithIndifferentAccess
 
   belongs_to :field_group
+  
+  scope :core_fields, where(:type => 'CoreField')
+  scope :custom_fields, where("type != 'CoreField'")
+  scope :without_pairs, where(:pair_id => nil)
 
   delegate :klass, :klass_name, :klass_name=, :to => :field_group
 
-  KLASSES = [Campaign, Lead, Contact, Account, Opportunity]
-
-  FIELD_TYPES = {
-    'string'      => :string,
-    'text'        => :text,
-    'email'       => :string,
-    'url'         => :string,
-    'tel'         => :string,
-    'select'      => :string,
-    'radio'       => :string,
-    'check_boxes' => :text,
-    'boolean'     => :boolean,
-    'date'        => :date,
-    'datetime'    => :timestamp,
-    'decimal'     => [:decimal, {:precision => 15, :scale => 2}],
-    'integer'     => :integer,
-    'float'       => :float
-  }
-
-  validates_presence_of :label, :message => "^Please enter a Field label."
-  validates_length_of :label, :maximum => 64, :message => "^The Field name must be less than 64 characters in length."
-
+  BASE_FIELD_TYPES = {
+    'string'      => {:klass => 'CustomField', :type => 'string'},
+    'text'        => {:klass => 'CustomField', :type => 'text'},
+    'email'       => {:klass => 'CustomField', :type => 'string'},
+    'url'         => {:klass => 'CustomField', :type => 'string'},
+    'tel'         => {:klass => 'CustomField', :type => 'string'},
+    'select'      => {:klass => 'CustomField', :type => 'string'},
+    'radio'       => {:klass => 'CustomField', :type => 'string'},
+    'check_boxes' => {:klass => 'CustomField', :type => 'text'},
+    'boolean'     => {:klass => 'CustomField', :type => 'boolean'},
+    'date'        => {:klass => 'CustomField', :type => 'date'},
+    'datetime'    => {:klass => 'CustomField', :type => 'timestamp'},
+    'decimal'     => {:klass => 'CustomField', :type => 'decimal', :column_options => {:precision => 15, :scale => 2} },
+    'integer'     => {:klass => 'CustomField', :type => 'integer'},
+    'float'       => {:klass => 'CustomField', :type => 'float'}
+  }.with_indifferent_access
+
+  validates_presence_of :label, :message => "^Please enter a field label."
+  validates_length_of :label, :maximum => 64, :message => "^The field name must be less than 64 characters in length."
   validates_numericality_of :maxlength, :only_integer => true, :allow_blank => true, :message => "^Max size can only be whole number."
-
-  validates_presence_of :as, :message => "^Please specify a Field type."
-  validates_inclusion_of :as, :in => FIELD_TYPES.keys, :message => "Invalid Field Type."
-
-
-  def self.field_types
-    # Expands concise FIELD_TYPES into a more usable hash
-    @field_types ||= FIELD_TYPES.inject({}) do |hash, n|
-      arr = [n[1]].flatten
-      hash[n[0]] = {:type => arr[0], :options => arr[1]}
-      hash
-    end
-  end
+  validates_presence_of :as, :message => "^Please specify a field type."
+  validates_inclusion_of :as, :in => Proc.new{self.field_types.keys}, :message => "^Invalid field type.", :allow_blank => true
 
   def column_type(field_type = self.as)
     (opts = Field.field_types[field_type]) ? opts[:type] : raise("Unknown field_type: #{field_type}")
   end
 
   def input_options
-    input_html = {:maxlength => attributes[:maxlength]}
-
+    input_html = {}
     attributes.reject { |k,v|
-      !%w(as collection disabled label placeholder required).include?(k) or v.blank?
-    }.symbolize_keys.merge(:input_html => input_html)
+      !%w(as collection disabled label placeholder required maxlength).include?(k) or v.blank?
+    }.symbolize_keys.merge(input_html)
   end
 
   def collection_string=(value)
@@ -110,15 +101,41 @@ class Field < ActiveRecord::Base
     when 'checkbox'
       value.to_s == '0' ? "no" : "yes"
     when 'date'
-      value && value.strftime(I18n.t("date.formats.default"))
+      value && value.strftime(I18n.t("date.formats.mmddyy"))
     when 'datetime'
-      value && value.strftime(I18n.t("time.formats.long"))
+      value && value.strftime(I18n.t("time.formats.mmddyyyy_hhmm"))
     when 'check_boxes'
-      value = YAML.load(value) if value.is_a?(String)
       value.select(&:present?).in_groups_of(2, false).map {|g| g.join(', ')}.join("<br />".html_safe) if Array === value
     else
       value.to_s
     end
   end
-end
 
+  protected
+
+  class << self
+
+    # Provides access to registered field_types
+    #------------------------------------------------------------------------------
+    def field_types
+      @@field_types ||= BASE_FIELD_TYPES
+    end
+
+    # Register custom fields so they are available to the rest of the app
+    # Example options: :as => 'datepair', :type => 'date', :klass => 'CustomFieldDatePair'
+    #------------------------------------------------------------------------------
+    def register(options)
+      opts = options.dup
+      as = options.delete(:as)
+      (@@field_types ||= BASE_FIELD_TYPES).merge!(as => options)
+    end
+
+    # Returns class name given a key
+    #------------------------------------------------------------------------------
+    def lookup_class(as)
+      (@@field_types ||= BASE_FIELD_TYPES)[as][:klass]
+    end
+
+  end
+
+end

data/app/models/fields/field_group.rb

@@ -49,14 +49,6 @@ class FieldGroup < ActiveRecord::Base
     klass_name.constantize
   end
 
-  def core_fields
-    fields.where(:type => 'CoreField')
-  end
-
-  def custom_fields
-    fields.where(:type => 'CustomField')
-  end
-
   def self.with_tags(tag_ids)
     where 'tag_id IS NULL OR tag_id IN (?)', tag_ids
   end
@@ -78,4 +70,3 @@ class FieldGroup < ActiveRecord::Base
     self.reload
   end
 end
-

data/app/models/observers/entity_observer.rb

@@ -0,0 +1,29 @@
+class EntityObserver < ActiveRecord::Observer
+  observe :account, :contact, :lead, :opportunity
+
+  def after_create(item)
+    send_notification_to_assignee(item) if current_user != item.assignee
+  end
+
+  def after_update(item)
+    if item.assigned_to_changed? && item.assignee != current_user
+      send_notification_to_assignee(item)
+    end
+  end
+
+  private
+
+  def send_notification_to_assignee(item)
+    UserMailer.assigned_entity_notification(item, current_user).deliver if item.assignee.present? && current_user.present?
+  end
+
+  def current_user
+    # this deals with whodunnit inconsistencies, where in some cases it's set to a user's id and others the user object itself
+    user_id_or_user = PaperTrail.whodunnit
+    if user_id_or_user.is_a?(User)
+      user_id_or_user
+    elsif user_id_or_user.is_a?(String)
+      User.find_by_id(user_id_or_user.to_i)
+    end
+  end
+end

data/app/models/observers/opportunity_observer.rb

@@ -35,9 +35,12 @@ class OpportunityObserver < ActiveRecord::Observer
     if original
       if original.stage != "won" && item.stage == "won"    # :other to :won -- add to total campaign revenue.
         update_campaign_revenue(item.campaign, (item.amount || 0) - (item.discount || 0))
+        item.update_attribute(:probability, 100) # Set probability to 100% if won
         return log_activity(item, :won)
       elsif original.stage == "won" && item.stage != "won" # :won to :other -- substract from total campaign revenue.
         update_campaign_revenue(original.campaign, -((original.amount || 0) - (original.discount || 0)))
+      elsif original.stage != "lost" && item.stage == "lost"
+        item.update_attribute(:probability, 0)   # Set probability to 0% if lost
       end
     end
   end

data/app/models/polymorphic/address.rb

@@ -53,4 +53,18 @@ class Address < ActiveRecord::Base
       self.full_address.blank?
     end
   end
+
+  #----------------------------------------------------------------------------
+  # Ensure blank address records don't get created. If we have a new record and
+  #   address is empty then return true otherwise return false so that _destroy
+  #   is processed (if applicable) and the record is removed.
+  # Intended to be called as follows:
+  #   accepts_nested_attributes_for :business_address, :allow_destroy => true, :reject_if => proc {|attributes| Address.reject_address(attributes)}
+  def self.reject_address(attributes)
+    exists = attributes['id'].present?
+    empty = %w(street1 street2 city state zipcode country full_address).map{|name| attributes[name].blank?}.all?
+    attributes.merge!({:_destroy => 1}) if exists and empty
+    return (!exists and empty)
+  end
+  
 end

data/app/models/polymorphic/avatar.rb

@@ -49,5 +49,17 @@ class Avatar < ActiveRecord::Base
   end
   has_attached_file :image, :styles => STYLES.dup, :url => "/avatars/:entity_type/:id/:style_:filename", :default_url => "/assets/avatar.jpg"
 
-end
+  # Convert STYLE symbols to 'w x h' format for Gravatar and Rails
+  # e.g. Avatar.size_from_style(:size => :large) -> '75x75'
+  # Allow options to contain :width and :height override keys
+  #----------------------------------------------------------------------------
+  def self.size_from_style!(options)
+    if options[:width] && options[:height]
+      options[:size] = [:width, :height].map{|d| options[d]}.join("x") 
+    elsif Avatar::STYLES.keys.include?(options[:size])
+      options[:size] = Avatar::STYLES[options[:size]].sub(/\#$/,'')
+    end
+    options
+  end
 
+end

data/app/models/polymorphic/email.rb

@@ -55,7 +55,7 @@ class Email < ActiveRecord::Base
     if defined?(RedCloth)
       RedCloth.new(body_without_textile).to_html.html_safe
     else
-      body_without_textile
+      body_without_textile.to_s.gsub("\n", "<br/>").html_safe
     end
   end
   alias_method_chain :body, :textile

data/app/models/polymorphic/task.rb

@@ -71,6 +71,17 @@ class Task < ActiveRecord::Base
     where('user_id = ? OR assigned_to = ?', user.id, user.id)
   }
 
+  scope :visible_on_dashboard, lambda { |user|
+    # Show opportunities which either belong to the user and are unassigned, or are assigned to the user
+    where('(user_id = :user_id AND assigned_to IS NULL) OR assigned_to = :user_id', :user_id => user.id).where('completed_at IS NULL')
+  }
+
+  scope :by_due_at, order({
+    "MySQL"      => "due_at NOT NULL, due_at ASC",
+    "PostgreSQL" => "due_at ASC NULLS FIRST"
+  }[ActiveRecord::Base.connection.adapter_name] || :due_at)
+
+
   # Status based scopes to be combined with the due date and completion time.
   scope :pending,       where('completed_at IS NULL').order('tasks.due_at, tasks.id')
   scope :assigned,      where('completed_at IS NULL AND assigned_to IS NOT NULL').order('tasks.due_at, tasks.id')
@@ -236,18 +247,8 @@ class Task < ActiveRecord::Base
   
   #----------------------------------------------------------------------------
   def parse_calendar_date
-    translate_month_and_day_names!(self.calendar) unless I18n.locale == :"en-US"
-    
-    DateTime.strptime(self.calendar,
-                      I18n.t(Setting.task_calendar_with_time ? 'time.formats.mmddyyyy_hhmm' : 'date.formats.mmddyyyy')).utc
+    # always in 2012-10-28 06:28 format regardless of language
+    Time.parse(self.calendar)
   end
-  
-  # Translates month and day names of a given datetime string.
-  #----------------------------------------------------------------------------
-  def translate_month_and_day_names!(date_string)
-    translated = I18n.t([:month_names, :abbr_month_names, :day_names, :abbr_day_names], :scope => :date).flatten.compact
-    original   = (Date::MONTHNAMES + Date::ABBR_MONTHNAMES + Date::DAYNAMES + Date::ABBR_DAYNAMES).compact
-    translated.each_with_index { |name, i| date_string.gsub!(name, original[i]) }
-  end
-end
 
+end

data/app/models/setting.rb

@@ -112,25 +112,13 @@ class Setting < ActiveRecord::Base
 
 
     # Loads settings from YAML files
-    def load_settings_from_yaml
-      @@yaml_settings = {}.with_indifferent_access
-
-      setting_files = [
-        FatFreeCRM.root.join("config", "settings.default.yml"),
-        Rails.root.join("config", "settings.yml")
-      ]
-
-      # Load default settings, then override with custom settings
-      setting_files.each do |file|
-        if File.exist?(file)
-          begin
-            settings = YAML.load_file(file)
-            # Merge settings into current settings hash (recursively)
-            @@yaml_settings.deep_merge!(settings)
-          rescue Exception => ex
-            puts "Settings couldn't be loaded from #{file}: #{ex.message}"
-          end
-        end
+    def load_settings_from_yaml(file)
+      begin
+        settings = YAML.load_file(file)
+        # Merge settings into current settings hash (recursively)
+        @@yaml_settings.deep_merge!(settings)
+      rescue Exception => ex
+        puts "Settings couldn't be loaded from #{file}: #{ex.message}"
       end
       yaml_settings
     end
@@ -138,5 +126,10 @@ class Setting < ActiveRecord::Base
 end
 
 
-# Preload YAML settings as soon as class is loaded.
-Setting.load_settings_from_yaml
+# Load default settings, then override with custom settings, if present.
+setting_files = [FatFreeCRM.root.join("config", "settings.default.yml")]
+# Don't override default settings in test environment
+setting_files << Rails.root.join("config", "settings.yml") unless Rails.env == 'test'
+setting_files.each do |settings_file|
+  Setting.load_settings_from_yaml(settings_file) if File.exist?(settings_file)
+end