e9_crm 0.1.1

data/app/models/campaign.rb

@@ -0,0 +1,34 @@
+# The base campaign class
+#
+# A Campaign is created with a unique code, which in turn generates PageViews,
+# which maybe become Leads (Offers), which may result in Deals.
+#
+class Campaign < ActiveRecord::Base
+  include E9Rails::ActiveRecord::STI
+
+  belongs_to :campaign_group
+  has_many   :deals, :inverse_of => :campaign
+  has_many   :page_views, :inverse_of => :campaign
+
+  # NOTE tracking cookie code changes with new visits
+  has_many   :tracking_cookies, :foreign_key => :code, :primary_key => :code, :class_name => 'TrackingCookie'
+
+  validates  :code, :presence   => true,
+                    :length     => { :maximum => 32 }, 
+                    :uniqueness => { :ignore_case => true }
+
+  scope :active,   lambda { where(:active => true) }
+  scope :inactive, lambda { where(:active => false) }
+
+  ##
+  # The sum cost of this campaign
+  # (Must be implemented by subclasses)
+  #
+  def cost
+    raise NotImplementedError
+  end
+
+  def to_s
+    name
+  end
+end

data/app/models/campaign_group.rb

@@ -0,0 +1,5 @@
+# An arbitrary grouping of campaigns for organizational use
+#
+class CampaignGroup < ActiveRecord::Base
+  has_many :campaigns
+end

data/app/models/company.rb

@@ -0,0 +1,4 @@
+# A company record, mainly an organizational tool for Contacts
+#
+class Company < ActiveRecord::Base
+end

data/app/models/contact.rb

@@ -0,0 +1,258 @@
+class Contact < ActiveRecord::Base
+  include E9Tags::Model
+  include E9Rails::ActiveRecord::AttributeSearchable
+
+  # necessary so contact knows its merge path
+  # NOTE in the future we'll probably want to give contacts public urls and make them 'Linkable'
+  include Rails.application.routes.url_helpers
+
+  before_validation :ensure_user_references
+
+  ##
+  # Associations
+  #
+  belongs_to :company
+
+  has_many :users, :inverse_of => :contact, :dependent => :nullify do
+
+    ##
+    # Resets the primary user on a contact
+    #
+    # == Parameters
+    #
+    # [options (Hash)] An options hash containing either the :id or :index
+    #                  of the User to set as primary.  If neither is set it
+    #                  will default the first User designated primary in the
+    #                  list, or the first user in the list if no such user
+    #                  exists.
+    #
+    #                  Also accepts a :save option, which will force save
+    #                  the User with no validation.
+    #
+    def reset_primary(options = {})
+      return if empty?
+      options.symbolize_keys!
+      options.slice!(:id, :index, :save)
+
+      should_save = options.delete(:save)
+
+      if options.empty?
+        if p = primary.first
+          options[:id] = p.id
+        else
+          options[:index] = 0
+        end
+      end
+
+      each_with_index do |user, i|
+        if options[:id]
+          user.options.primary = options[:id] == user.id
+        else
+          user.options.primary = options[:index] == i
+        end
+
+        user.save(:validate => false) if should_save && user.options_changed?
+      end
+    end
+
+    ##
+    # Resets the primary User, forcing :save
+    #
+    def reset_primary!(options = {})
+      reset_primary options.merge(:save => true)
+    end
+
+    ##
+    # Clears all users of primary status, used when merging/resetting Contacts.
+    # Does not force save.
+    #
+    def clear_primary(options = {})
+      reset_primary options.merge(:index => -1)
+    end
+
+    ##
+    # Clears all users of primary status, used when merging/resetting Contacts,
+    # Fores save.
+    #
+    def clear_primary!
+      clear_primary :save => true 
+    end
+  end
+  accepts_nested_attributes_for :users, :allow_destroy => true
+
+  def page_views
+    PageView.by_user(users)
+  end
+
+  has_many :record_attributes, :as => :record
+  RECORD_ATTRIBUTES = %w[users phone_number_attributes instant_messaging_handle_attributes website_attributes address_attributes]
+  # NOTE Mind the hack here, "users" are "attributes" but not added in this loop.  This was so the RECORD_ATTRIBUTES constant
+  #      would include :users (for building the templates.js).
+  RECORD_ATTRIBUTES.select {|r| r =~ /attributes$/ }.each do |association_name|
+    has_many association_name.to_sym, :class_name => association_name.classify, :as => :record
+    accepts_nested_attributes_for association_name.to_sym, :allow_destroy => true, :reject_if => :reject_record_attribute?
+  end
+
+  ##
+  # Validations
+  #
+  validates :first_name, :presence => true, :length => { :maximum => 25 }
+
+  ##
+  # Scopes
+  #
+
+  # NOTE contact#search feels terribly fragile and needs work.  
+  #
+  # The issue lies in the need to outer join record_attributes because the 
+  # join is optional.
+  #
+  # We end up with multiple rows per Contact.  This could be solved
+  # by a distinct select, but that breaks when we need to do things
+  # like User.joins(:contact) & Contact.search("whatever")
+  #
+  # While it's like this, note that #search groups (hardcoded on "contacts")
+  #
+  scope :search, lambda {|query|
+    join_sql = %{
+      LEFT OUTER JOIN record_attributes 
+        ON record_attributes.record_id = contacts.id
+        AND record_attributes.record_type = 'Contact'
+      LEFT OUTER JOIN users
+        ON users.contact_id = contacts.id
+    }
+
+    joins(join_sql).group('contacts.id').where(
+      any_attrs_like_scope_conditions(:first_name, :last_name, :title, query)
+        .or(RecordAttribute.attr_like_scope_condition(:value, query))
+        .or(User.attr_like_scope_condition(:email, query))
+    )
+  }
+  scope :by_title, lambda {|val| where(:title => val) }
+  scope :by_company, lambda {|val| where(:company_id => val) }
+  scope :tagged, lambda {|tags| 
+    if tags.present?
+      tagged_with(tags, :show_hidden => true, :any => true) 
+    else
+      where("1=0")
+    end
+  }
+
+  # The parameters for building the JS template for associated users
+  def self.users_build_parameters # :nodoc:
+    { :status => User::Status::PROSPECT }
+  end
+
+  ##
+  # Setting company name will attempt to find a Company or create a new one
+  #
+  def company_name=(value)
+    if value.present?
+      if existing_company = Company.find_by_name(value)
+        self.company = existing_company
+      else
+        self.build_company(:name => value)
+      end
+    else
+      self.company = nil
+    end
+  end
+  delegate :name, :to => :company, :prefix => true, :allow_nil => true
+
+  ##
+  # Helper to concatenate a Contact's full name
+  #
+  def name
+    [first_name, last_name].join(' ')
+  end
+
+  def merge_and_destroy!(other_contact)
+    other_contact.users.clear_primary!
+
+    self.users                               |= other_contact.users
+    self.website_attributes                  |= other_contact.website_attributes
+    self.address_attributes                  |= other_contact.address_attributes
+    self.phone_number_attributes             |= other_contact.phone_number_attributes
+    self.instant_messaging_handle_attributes |= other_contact.instant_messaging_handle_attributes
+
+    other_contact.destroy
+  end
+
+  def valid?(context = nil)
+    #
+    # NOTE #valid? manages duplicate users and is a destructive process!
+    # TODO move the logic that deletes/manages duplicate email'd users out of 
+    #      #valid?, which probably should not be destructive
+    #
+    # When checking for validity, we're also checking to see if Users are being added
+    # which have emails that already exist in the database.  If one is found, one of
+    # two things will happen, depending on whether or not that User already has a
+    # Contact record.  
+    #
+    # A.) If it does, the validation will return false immediately and add an error 
+    #     suggesting a Contact merge.
+    #
+    # B.) If it does not, no error will be added, but the offending "user" association
+    #     will be deleted and the Contact will be related to the pre-existing User with 
+    #     that email.
+    #
+    # If more than one user associations are passed with the same email, it will be treated 
+    # as a normal uniqueness error, until all emails passed are unique. At which time we
+    # go back to the A/B scenario above.
+    #
+    super || begin
+      unless errors.delete(:"users.email").blank?
+        users.dup.each_with_index do |user, i|
+          user.errors[:email].each do |error|
+            if error.taken? && users.select {|u| u.email == user.email }.length == 1
+              existing_user = User.find_by_email(user.email)
+
+              if contact = existing_user.contact
+                args = if new_record?
+                  [contact, 'new', {:contact => self.attributes}]
+                else
+                  [contact, self]
+                end
+
+                errors.add(:users, :merge_required, {
+                  :email => user.email, 
+                  :merge_path => new_contact_merge_path(*args)
+                })
+
+                return false
+              else
+                self.users.delete(user)
+                self.users << existing_user
+              end
+            else
+              if error.label
+                errors.add(:users, error.label.to_sym, :email => user.email)
+              else
+                errors.add(:users, nil, :message => error, :email => user.email)
+              end
+            end
+          end
+        end
+
+        errors[:users].uniq!
+        errors[:users].empty?
+      end
+    end
+  end
+
+  protected
+
+    def ensure_user_references
+      users.each {|u| u.contact = self }
+    end
+
+    # override has_destroy_flag? to force destroy on persisted associations as well
+    def has_destroy_flag?(hash)
+      reject_record_attribute?(hash) || super 
+    end
+
+    def reject_record_attribute?(attributes)
+      attributes.keys.member?('value') && attributes['value'].blank?
+    end
+
+end

data/app/models/contact_email.rb

@@ -0,0 +1,49 @@
+# A ContactEmail is a one time mail generated from an EmailTemplate, sent not to a 
+# list, but to a set of user_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
+
+  after_create :send_to_user_ids
+
+  class << self
+    def new_from_template(template, attrs = {})
+      new({
+        :name => "#{template.name} - #{DateTime.now.to_i}",
+        :subject => template.subject,
+        :html_body => template.html_body,
+        :text_body => template.text_body
+      }.merge(attrs))
+    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
+
+    @user_ids.map!(&:to_i)
+  end
+
+
+  protected
+
+  def send_to_user_ids
+    Rails.logger.info("ContactEmail##{id} sending to user ids #{user_ids}")
+    send!(user_ids)
+  end
+end

data/app/models/dated_cost.rb

@@ -0,0 +1,9 @@
+#
+# Encapulates a Cost and a Date, used to track costs by
+# date so sums for date ranges can be generated.
+#
+class DatedCost < ActiveRecord::Base
+  money_columns :cost
+  belongs_to :costable, :polymorphic => true
+  validates :date, :date => true
+end

data/app/models/deal.rb

@@ -0,0 +1,83 @@
+# Generated from a Lead, owned by a Campaign.  Deals represent potential
+# "deals" with contacts and track revenue used for marketing reports.
+#
+class Deal < ActiveRecord::Base
+  include E9Rails::ActiveRecord::Initialization
+
+  belongs_to :campaign, :inverse_of => :deal
+  belongs_to :tracking_cookie, :inverse_of => :deal
+  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)
+  }
+
+  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) }
+
+  validate do |record|
+    return unless record.status_changed?
+
+    case record.status
+    when Status::Lead
+      if [Status::Won, Status::Lost].member?(record.status_was)
+        record.errors.add(:status, :illegal_reversion)
+      elsif record.persisted?
+        # "revert" isn't happening on new records
+        record.send :_do_revert
+      end
+    when Status::Pending
+      if record.status_was == Status::Lead
+        record.send :_do_convert
+      end
+    when Status::Won, Status::Lost
+      if record.status_was == Status::Lead
+        record.errors.add(:status, :illegal_conversion)
+      end
+    else
+      record.errors.add(:status, :invalid, :options => Status::OPTIONS.join(', '))
+    end
+  end
+
+  protected
+
+    def method_missing(method_name, *args)
+      if method_name =~ /(.*)\?$/ && Status::OPTIONS.member?($1)
+        self.status == $1
+      else
+        super
+      end
+    end
+
+    def _do_convert
+      self.converted_at = Time.now.utc
+      notify_observers :before_convert
+    end
+
+    def _do_revert
+      self.converted_at = nil
+      notify_observers :before_revert
+    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
+    end
+
+  module Status
+    OPTIONS  = %w(lead pending won lost)
+    Lead    = OPTIONS[0]
+    Pending = OPTIONS[1]
+    Won     = OPTIONS[2]
+    Lost    = OPTIONS[3]
+  end
+end

data/app/models/email_campaign.rb

@@ -0,0 +1,13 @@
+# An email campaign.
+#
+class EmailCampaign < Campaign
+
+  ##
+  # The sum cost of this campaign
+  #
+  # NOTE How much does an email campaign 'cost'?
+  #
+  def cost
+    Money.new(1)
+  end
+end

data/app/models/email_template.rb

@@ -0,0 +1,7 @@
+# An "Email" that isn't intended to be sent, but rather as a prototype
+# for other Emails to be generated from.
+#
+class EmailTemplate < Email
+  # TODO the email class hierarchy needs a major refactoring, it's backwards and convoluted
+  before_save :generate_html_body_from_text_body
+end

data/app/models/instant_messaging_handle_attribute.rb

@@ -0,0 +1,4 @@
+# An instant messaging handle type, e.g. AIM, Skype
+#
+class InstantMessagingHandleAttribute < RecordAttribute
+end

data/app/models/menu_option.rb

@@ -0,0 +1,33 @@
+# A simple class to manage menu options, usable by other classes to build their menus.
+#
+class MenuOption < ActiveRecord::Base
+  KEYS = [
+    'Deal Category',
+    'Email',
+    'Instant Messaging Handle',
+    'Phone Number',
+    #'Task Category',
+    #'Task Status',
+    'Website'
+  ].freeze
+
+  validates :value, :presence  => true
+  validates :key,   :presence  => true, :inclusion => { :in => KEYS, :allow_blank => true }
+
+  acts_as_list :scope => 'menu_options.key = \"#{key}\"'
+
+  scope :options_for, lambda {|key| where(:key => key) }
+
+  ##
+  # A direct SQL selection of values for a given key
+  #
+  #   MenuOption.fetch('Email') #=> ['Personal','Work']
+  #
+  # === Parameters
+  #
+  # [key (String)] The key for the assocated menu options.
+  #
+  def self.fetch_values(key)
+    connection.send(:select_values, options_for(key).order(:position).project('value').to_sql, 'Menu Option Select')
+  end
+end

data/app/models/offer.rb

@@ -0,0 +1,50 @@
+# A +Renderable+ which "offers" the user something.  Responses to these
+# offers are tracked as +Leads+
+#
+class Offer < Renderable
+  has_many :deals, :inverse_of => :offer
+  has_many :leads, :class_name => 'Deal', :conditions => ["deals.status = ?", Deal::Status::Lead]
+
+  class << self
+    def conversion_email
+      SystemEmail.find_by_identifier(Identifiers::CONVERSION_EMAIL)
+    end
+
+    def page
+      SystemPage.find_by_identifier(Identifiers::PAGE)
+    end
+  end
+
+  include E9Rails::ActiveRecord::InheritableOptions
+  self.delegate_options_methods = true
+  self.options_parameters = [
+    :submit_button_text,
+    :success_alert_text,
+    :download_link_text,
+    :conversion_alert_email,
+    :success_page_text,
+    :custom_form_html
+  ]
+
+  mount_uploader :file, FileUploader
+
+  validates :conversion_alert_email, :email => { :allow_blank => true }
+
+  def to_s
+    name
+  end
+
+  def as_json(options={})
+    {}.tap do |hash|
+      hash[:id]       = self.id,
+      hash[:name]     = self.name,
+      hash[:template] = self.template,
+      hash[:errors]   = self.errors
+    end
+  end
+
+  module Identifiers
+    CONVERSION_EMAIL = 'offer_conversion_email'
+    PAGE             = 'offer_page'
+  end
+end

data/app/models/page_view.rb

@@ -0,0 +1,80 @@
+# A visit to the site
+# 
+# Page views belong to a tracking cookie, from which it derives its
+# campaign code, and whether or not it is a "new visit" for the given
+# campaign code.
+#
+# === Also stored from the request:
+#
+# [request_path] The full request path
+# [user_agent]   The request user agent
+# [referer]      The request referer if it exists
+# [remote_ip]    The originating ip address of the request
+# [session]      The session id of the request
+#
+class PageView < ActiveRecord::Base
+  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 
+
+        # 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
+  }
+
+  scope :by_user, lambda {|*users| 
+    users.flatten!
+    users.map! &:to_param
+    joins(:tracking_cookie).where(TrackingCookie.arel_table[:user_id].send *(users.length == 1 ? [:eq, users.pop] : [:in, users]))
+  }
+
+  scope :by_campaign, lambda {|*campaigns| 
+    campaigns.flatten!
+    campaigns.map! &:to_param
+    where(arel_table[:campaign_id].send *(campaigns.length == 1 ? [:eq, campaigns.pop] : [:in, campaigns]))
+  }
+
+  delegate :name, :code, :to => :campaign, :prefix => true, :allow_nil => true
+end

data/app/models/phone_number_attribute.rb

@@ -0,0 +1,4 @@
+# A phone number type, e.g. (Home, Work, Mobile)
+#
+class PhoneNumberAttribute < RecordAttribute
+end

data/app/models/record_attribute.rb

@@ -0,0 +1,41 @@
+# An arbitrary 'attribute' attachable to records.  
+#
+# Gets support for arbitrary options via InheritableOptions.  By default it 
+# has one option, +type+, but subclasses could extend for further options by
+# overwriting +options_parameters+.
+#
+# By default, the +type+ options are managed via the +MenuOption+ class.
+#
+class RecordAttribute < ActiveRecord::Base
+  include E9Rails::ActiveRecord::STI
+  include E9Rails::ActiveRecord::AttributeSearchable
+  include E9Rails::ActiveRecord::InheritableOptions
+  
+  self.options_parameters = [:type]
+
+  belongs_to :record, :polymorphic => true
+
+  ##
+  # Looks up the available +types+ for this attribute by fetching a 
+  # titleized version of the class name from +MenuOption+.
+  #
+  # e.g.
+  #   
+  #   PhoneNumberAttribute.types
+  #
+  # is equivalent to:
+  #
+  #   MenuOption.fetch_values('Phone Number')
+  #
+  def self.types
+    if name =~ /^(\w+)Attribute$/ 
+      MenuOption.fetch_values($1.titleize)
+    else 
+      []
+    end
+  end
+
+  def to_s
+    options.type ? "#{value} (#{options.type})" : value
+  end
+end