e9_crm 0.1.1 → 0.1.4

data/app/models/campaign_group.rb

@@ -2,4 +2,10 @@
 #
 class CampaignGroup < ActiveRecord::Base
   has_many :campaigns
+
+  validates :name, :uniqueness => { :ignore_case => true }
+
+  def to_s
+    name
+  end
 end

data/app/models/contact.rb

@@ -1,6 +1,7 @@
 class Contact < ActiveRecord::Base
   include E9Tags::Model
   include E9Rails::ActiveRecord::AttributeSearchable
+  include E9Rails::ActiveRecord::Initialization
 
   # necessary so contact knows its merge path
   # NOTE in the future we'll probably want to give contacts public urls and make them 'Linkable'
@@ -128,6 +129,11 @@ class Contact < ActiveRecord::Base
         .or(User.attr_like_scope_condition(:email, query))
     )
   }
+
+  scope :sales_persons, lambda { where(:status => Status::SalesPerson) }
+  scope :affiliates, lambda { where(:status => Status::Affiliate) }
+  scope :contacts, lambda { where(:status => Status::Contact) }
+
   scope :by_title, lambda {|val| where(:title => val) }
   scope :by_company, lambda {|val| where(:company_id => val) }
   scope :tagged, lambda {|tags| 
@@ -138,6 +144,12 @@ class Contact < ActiveRecord::Base
     end
   }
 
+  #
+  # Carrierwave
+  #
+  mount_uploader :avatar, AvatarUploader
+  def thumb(options = {}); self.avatar end
+
   # The parameters for building the JS template for associated users
   def self.users_build_parameters # :nodoc:
     { :status => User::Status::PROSPECT }
@@ -242,6 +254,10 @@ class Contact < ActiveRecord::Base
 
   protected
 
+    def _assign_initialization_defaults
+      self.status ||= Status::Contact
+    end
+
     def ensure_user_references
       users.each {|u| u.contact = self }
     end
@@ -255,4 +271,10 @@ class Contact < ActiveRecord::Base
       attributes.keys.member?('value') && attributes['value'].blank?
     end
 
+  module Status
+    VALUES      = %w(contact sales_person affiliate)
+    Contact     = VALUES[0]
+    SalesPerson = VALUES[1]
+    Affiliate   = VALUES[2]
+  end
 end

data/app/models/contact_email.rb

@@ -1,14 +1,12 @@
 # A ContactEmail is a one time mail generated from an EmailTemplate, sent not to a 
-# list, but to a set of user_ids.
+# list, but to a set of contact_ids.
 #
 class ContactEmail < Email
   include ScheduledEmail
   before_save :generate_html_body_from_text_body
 
-  # NOTE perhaps contact_email should validate contact ids?  Then again, 
-  #      then it would be necessary to ensure the contacts had primary email 
-  #      addresses
-  validates :user_ids, :presence => true
+  validates :contact_ids, :presence => true
+  validates :user_ids, :presence => { :unless => lambda {|r| r.contact_ids.blank? } }
 
   after_create :send_to_user_ids
 
@@ -23,23 +21,36 @@ class ContactEmail < Email
     end
   end
 
-  attr_reader :user_ids
-
-  # user_ids only gets set if it's an array or a properly formatted string
-  def user_ids=(val)
-    @user_ids = case val
-                when /^\[?((\d+,?\s?)+)\]?$/
-                  $1.split(',')
-                when Array
-                  val
-                else
-                  []
-                end
+  # contact_ids only gets set if it's an array or a properly formatted string
+  def contact_ids=(val)
+    @contact_ids = case val
+                   when /^\[?((\d+,?\s?)+)\]?$/
+                     $1.split(',')
+                   when Array
+                     val
+                   else
+                     []
+                   end
+
+    # clear user_ids cache
+    @user_ids = nil
+  end
 
-    @user_ids.map!(&:to_i)
+  def contact_ids
+    (@contact_ids ||= []).map(&:to_i)
   end
 
 
+  def user_ids 
+    @user_ids ||= if @contact_ids.present?
+      user_scope  = (User.primary.joins(:contact) & Contact.where(:id => @contact_ids))
+      user_id_sql = user_scope.select('users.id').to_sql
+      User.connection.send(:select_values, user_id_sql, 'User ID Load')
+    else
+      []
+    end
+  end
+
   protected
 
   def send_to_user_ids

data/app/models/deal.rb

@@ -3,25 +3,80 @@
 #
 class Deal < ActiveRecord::Base
   include E9Rails::ActiveRecord::Initialization
+  include E9Rails::ActiveRecord::Scopes::Times
 
-  belongs_to :campaign, :inverse_of => :deal
-  belongs_to :tracking_cookie, :inverse_of => :deal
+  belongs_to :campaign, :inverse_of => :deals
+  belongs_to :tracking_cookie, :inverse_of => :deals
   belongs_to :offer, :inverse_of => :deals
 
-  scope :column_op, lambda {|op, column, value, reverse=false|
-    conditions = arel_table[column].send(op, value)
-    conditions = conditions.not if reverse
-    where(conditions)
-  }
+  money_columns :value
+  validates :value, :numericality => true
 
-  scope :column_eq, lambda {|column, value, reverse=false|
-    column_op(:eq, column, value, reverse)
+  %w(total_value average_value total_cost average_cost).each do |money_column|
+    class_eval("def #{money_column}; (r = read_attribute(:#{money_column})) && Money.new(r) end")
+  end
+
+  scope :reports, lambda {
+    select_sql = <<-SELECT.gsub(/\s+/, ' ')
+      campaigns.id                            campaign_id,
+      campaigns.type                          campaign_type,
+      campaigns.name                          campaign_name,
+      campaign_groups.name                    campaign_group,
+      SUM(IF(deals.status != 'lead',1,0))     deal_count, 
+      COUNT(deals.id)                         lead_count,
+      SUM(IF(deals.status='won',1,0))         won_deal_count,
+      campaigns.new_visits                    new_visits, 
+      campaigns.repeat_visits                 repeat_visits, 
+
+      SUM(IF(deals.status='won',value,0))     total_value, 
+      AVG(IF(deals.status='won',value,NULL))  average_value, 
+
+      (CASE campaigns.type
+        WHEN "SalesCampaign"       
+          THEN SUM(campaigns.sales_fee)
+        WHEN "AdvertisingCampaign" 
+          THEN dated_costs.cost 
+        WHEN "AffiliateCampaign"   
+          THEN SUM(campaigns.sales_fee + 
+                   campaigns.affiliate_fee)
+        ELSE 
+          0 
+        END)                                   total_cost,
+
+      (CASE campaigns.type
+        WHEN "SalesCampaign"       
+          THEN campaigns.sales_fee
+        WHEN "AdvertisingCampaign" 
+          THEN dated_costs.cost 
+        WHEN "AffiliateCampaign"   
+          THEN campaigns.sales_fee + 
+                 campaigns.affiliate_fee
+        ELSE 
+          0 
+        END / COUNT(deals.id))                 average_cost,
+
+      FLOOR(AVG(
+        DATEDIFF(
+          deals.closed_at,
+          deals.created_at)))                  average_elapsed
+
+    SELECT
+
+    join_sql = <<-JOINS.gsub(/\s+/, ' ')
+      LEFT OUTER JOIN dated_costs 
+        ON deals.campaign_id          = dated_costs.costable_id 
+        AND dated_costs.costable_type = "Campaign" 
+
+      LEFT OUTER JOIN campaigns 
+        ON campaigns.id = deals.campaign_id 
+
+      LEFT OUTER JOIN campaign_groups
+        ON campaign_groups.id = campaigns.campaign_group_id
+    JOINS
+
+    select(select_sql).joins(join_sql).group(:campaign_id)
   }
 
-  scope :leads,   lambda {|reverse=true| column_eq(:status, Status::Lead, !reverse) }
-  scope :pending, lambda {|reverse=true| column_eq(:status, Status::Pending, !reverse) }
-  scope :won,     lambda {|reverse=true| column_eq(:status, Status::Won, !reverse) }
-  scope :lost,    lambda {|reverse=true| column_eq(:status, Status::Lost, !reverse) }
 
   validate do |record|
     return unless record.status_changed?
@@ -41,12 +96,31 @@ class Deal < ActiveRecord::Base
     when Status::Won, Status::Lost
       if record.status_was == Status::Lead
         record.errors.add(:status, :illegal_conversion)
+      elsif record.persisted?
+        # "close" isn't happening on new records
+        record.send :_do_close
       end
     else
       record.errors.add(:status, :invalid, :options => Status::OPTIONS.join(', '))
     end
   end
 
+  scope :column_op, lambda {|op, column, value, reverse=false|
+    conditions = arel_table[column].send(op, value)
+    conditions = conditions.not if reverse
+    where(conditions)
+  }
+
+  scope :column_eq, lambda {|column, value, reverse=false|
+    column_op(:eq, column, value, reverse)
+  }
+
+  scope :leads,   lambda {|reverse=true| column_eq(:status, Status::Lead, !reverse) }
+  scope :pending, lambda {|reverse=true| column_eq(:status, Status::Pending, !reverse) }
+  scope :won,     lambda {|reverse=true| column_eq(:status, Status::Won, !reverse) }
+  scope :lost,    lambda {|reverse=true| column_eq(:status, Status::Lost, !reverse) }
+
+
   protected
 
     def method_missing(method_name, *args)
@@ -66,11 +140,16 @@ class Deal < ActiveRecord::Base
       self.converted_at = nil
       notify_observers :before_revert
     end
+
+    def _do_close
+      self.closed_at = nil
+      notify_observers :before_close
+    end
   
     # Typically, new Deals are 'pending', with the assumption that offers
     # explicitly create Deals as 'lead' when they convert.
     def _assign_initialization_defaults
-      self.status = Status::Pending
+      self.status ||= Status::Pending
     end
 
   module Status

data/app/models/no_campaign.rb

@@ -0,0 +1,5 @@
+class NoCampaign < Campaign
+  def name
+    self.class.human_attribute_name(:name)
+  end
+end

data/app/models/page_view.rb

@@ -13,56 +13,16 @@
 # [session]      The session id of the request
 #
 class PageView < ActiveRecord::Base
+  include E9Rails::ActiveRecord::Scopes::Times
+
   belongs_to :tracking_cookie
 
   belongs_to :campaign, :inverse_of => :page_views
   has_one :user, :through => :tracking_cookie
 
-  scope :new_visits,    lambda {|v=true| where(:new_visit => v) }
-  scope :repeat_visits, lambda { new_visits(false) }
-
-  scope :from_time, lambda {|*args| 
-    args.flatten!
-    for_time_range(args.shift, nil, args.extract_options!)
-  }
-
-  scope :until_time, lambda {|*args| 
-    args.flatten!
-    for_time_range(nil, args.shift, args.extract_options!)
-  }
-
-  scope :for_time_range, lambda {|*args|
-    opts = args.extract_options!
-
-    args.flatten!
-
-    # try to determine a datetime from each arg, skipping #to_time on passed strings because
-    # it doesn't handle everything DateTime.parse can, e.g. 'yyyy/mm'
-    args.map! do |t| 
-      t.presence and 
+  attr_accessor :should_cache 
 
-        # handle string years 2010, etc.
-        t.is_a?(String) && /^\d{4}$/.match(t) && Date.civil(t.to_i) ||
-
-        # handle Time etc. (String#to_time doesn't handle yyyy/mm properly)
-        !t.is_a?(String) && t.respond_to?(:to_time) && t.to_time || 
-
-        # try to parse it
-        DateTime.parse(t) rescue nil
-    end
-
-    time_column = opts[:column] || :created_at
-
-    if !args.any?
-      where('1=0')
-    elsif args.all?
-      where(time_column => args[0]..args[1])
-    elsif args[0]
-      where(arel_table[time_column].gteq(args[0]))
-    else
-      where(arel_table[time_column].lteq(args[1]))
-    end
-  }
+  after_create :increment_campaign_visit_cache, :if => '!!should_cache'
 
   scope :by_user, lambda {|*users| 
     users.flatten!
@@ -76,5 +36,14 @@ class PageView < ActiveRecord::Base
     where(arel_table[:campaign_id].send *(campaigns.length == 1 ? [:eq, campaigns.pop] : [:in, campaigns]))
   }
 
+  scope :new_visits,    lambda {|v=true| where(:new_visit => v) }
+  scope :repeat_visits, lambda { new_visits(false) }
+
   delegate :name, :code, :to => :campaign, :prefix => true, :allow_nil => true
+
+  protected
+
+  def increment_campaign_visit_cache
+    Campaign.increment_counter(new_visit ? :new_visits : :repeat_visits, campaign_id)
+  end
 end

data/app/models/tracking_cookie.rb

@@ -45,12 +45,6 @@ class TrackingCookie < ActiveRecord::Base
   has_many :page_views
   after_save :generate_hid, :on => :create
 
-  attr_accessor :new_visit
-
-  def new_visit?
-    @new_visit.present?
-  end
-
   protected
 
   def generate_hid

data/app/observers/deal_observer.rb

@@ -2,6 +2,9 @@ class DealObserver < ActiveRecord::Observer
   def before_revert(record)
   end
 
+  def before_close(record)
+  end
+
   def before_convert(record)
     if email = record.offer && record.offer.conversion_alert_email.presence
       Rails.logger.debug("Sending Offer Conversion Alert to [#{email}]")

data/app/views/e9_crm/advertising_campaigns/_form_inner.html.haml

@@ -0,0 +1 @@
+= render 'e9_crm/campaigns/form_inner', :f => f

data/app/views/e9_crm/affiliate_campaigns/_form_inner.html.haml

@@ -0,0 +1,10 @@
+= render 'e9_crm/sales_campaigns/form_inner', :f => f
+
+%fieldset
+  %legend= e9_t(:affiliate_information_legend, :scope => 'e9_crm.campaigns')
+  .field
+    = f.label :affilate_id
+    = f.collection_select :affiliate_id, Contact.affiliates.all, :id, :name, :prompt => true
+  .field
+    = f.label :affiliate_fee
+    = f.text_field :affiliate_fee

data/app/views/e9_crm/campaign_groups/_header.html.haml

@@ -0,0 +1,3 @@
+.toolbar
+  .toolbar-right
+    = link_to_new_resource(CampaignGroup)

data/app/views/e9_crm/campaigns/_form_inner.html.haml

@@ -1,5 +1,21 @@
-- resource.attributes.each_pair do |field, value|
-  - next if ['id', 'created_at', 'updated_at'].include?(field)
+%fieldset
+  %legend= e9_t(:campaign_information_legend, :scope => 'e9_crm.campaigns')
   .field
-    = f.label field
-    = f.text_field field
+    = f.label :campaign_group_id
+    = f.collection_select :campaign_group_id, CampaignGroup.all, :id, :name, :include_blank => 'No Group'
+  .field
+    = f.label :name
+    = f.text_field :name
+  - if f.object.new_record?
+    .field#campaign_code_field
+      = f.label :code
+      = f.text_field :code
+  .field
+    %label{:for => 'campaign_code_hint'}
+      = resource_class.human_attribute_name(:code_hint)
+      %span.help{:title => e9_t(:code_help, :scope => 'e9_crm.campaigns', :code => E9Crm.query_param)}= t(:inline_help_link)
+    #campaign_code_hint= "?#{E9Crm.query_param}=#{f.object.code}"
+  .field
+    = f.label :active
+    = f.check_box :active
+

data/app/views/e9_crm/campaigns/_header.html.haml

@@ -0,0 +1,16 @@
+.toolbar
+  .toolbar-left
+    = form_tag(resource_class, :method => :get, :id => 'campaign_search_form') do
+      %select{:name => 'type'}
+        = campaign_type_select_options
+      %select{:name => 'group'}
+        = campaign_group_select_options
+      %select{:name => 'active'}
+        = campaign_active_select_options
+
+  .toolbar-right
+    = form_tag new_advertising_campaign_path, :method => :get, :id => 'new_campaign_form' do
+      = label_tag 'new_campaign_type_select', t('activerecord.links.new', :model => Campaign.model_name.human)
+      %select{:name => 'type', :id => 'new_campaign_type_select'}
+        = campaign_type_select_options(false)
+        = submit_tag t(:go)