fat_free_crm 0.11.1 → 0.11.2

data/fat_free_crm.gemspec

@@ -22,28 +22,22 @@ Gem::Specification.new do |gem|
   gem.add_dependency 'authlogic',           '~> 3.1.0'
   gem.add_dependency 'acts_as_commentable', '~> 3.0.1'
   gem.add_dependency 'acts-as-taggable-on', '~> 2.2.1'
-  gem.add_dependency 'responds_to_parent'
   gem.add_dependency 'dynamic_form'
   gem.add_dependency 'haml',                '~> 3.1.3'
-  gem.add_dependency 'sass',                '~> 3.1.15'
+  gem.add_dependency 'sass',                '~> 3.1.10'
   gem.add_dependency 'acts_as_list',        '~> 0.1.4'
   gem.add_dependency 'ffaker',              '>= 1.12.0'
-  gem.add_dependency 'uglifier'
-  gem.add_dependency 'chosen-rails'
-  gem.add_dependency 'ajax-chosen-rails',   '>= 0.1.5'
-  gem.add_dependency 'ransack'
   gem.add_dependency 'cancan'
+  gem.add_dependency 'premailer'
+  gem.add_dependency 'nokogiri'
+  gem.add_dependency 'squeel',              '~> 0.9.3'
 
-  gem.add_development_dependency 'rspec-rails',  '~> 2.8.1'
-  gem.add_development_dependency 'capybara'
-  gem.add_development_dependency 'sass-rails'
-  gem.add_development_dependency 'coffee-rails'
-  gem.add_development_dependency 'therubyracer'
-  gem.add_development_dependency 'spork'
-  gem.add_development_dependency 'database_cleaner'
-  gem.add_development_dependency 'fuubar'
-  gem.add_development_dependency 'factory_girl', '~> 2.6.1'
-  gem.add_development_dependency 'factory_girl_rails', '~> 1.7.0'
-end
-
+  # FatFreeCRM has released it's own versions of the following gems:
+  #-----------------------------------------------------------------
+  gem.add_dependency 'ransack_ffcrm',       '~> 0.6.0'
+  gem.add_dependency 'chosen-rails_ffcrm'
+  gem.add_dependency 'ajax-chosen-rails',   '>= 0.2.0'  # (now depends on chosen-rails_ffcrm)
+  gem.add_dependency 'responds_to_parent_ffcrm'
+  gem.add_dependency 'email_reply_parser_ffcrm'
 
+end

data/lib/fat_free_crm.rb

@@ -54,5 +54,4 @@ require "fat_free_crm/fields"
 require "fat_free_crm/sortable"
 require "fat_free_crm/tabs"
 require "fat_free_crm/callback"
-require "fat_free_crm/dropbox" if defined?(::Rake)
 require "fat_free_crm/plugin"

data/lib/fat_free_crm/core_ext/array.rb

@@ -41,6 +41,7 @@ class Array
           else
             item.send(column)
           end
+          value = value.to_a.join(',') if [Set, Array].include?(value.class)
           value.to_s.wrap(%Q|<Cell><Data ss:Type="#{value.respond_to?(:abs) ? 'Number' : 'String'}">|, '</Data></Cell>')
         end.join.wrap('<Row>', '</Row>')
       end

data/lib/fat_free_crm/gem_dependencies.rb

@@ -34,6 +34,7 @@ require 'ajax-chosen-rails'
 require 'ransack'
 require 'paper_trail'
 require 'cancan'
+require 'squeel'
 
 # Load redcloth if available (for textile markup in emails)
 begin

data/lib/fat_free_crm/mail_processor/base.rb

@@ -0,0 +1,226 @@
+# 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/>.
+#------------------------------------------------------------------------------
+
+require 'net/imap'
+require 'mail'
+require 'email_reply_parser'
+require 'premailer'
+require 'nokogiri'
+
+module FatFreeCRM
+  module MailProcessor
+    class Base
+      KEYWORDS = %w(account campaign contact lead opportunity).freeze
+
+      #--------------------------------------------------------------------------------------
+      def initialize
+        @archived, @discarded, @dry_run = 0, 0, false
+      end
+
+      # Setup imap folders in settings.
+      #--------------------------------------------------------------------------------------
+      def setup
+        log "connecting to #{@settings[:server]}..."
+        connect!(:setup => true) or return nil
+        log "logged in to #{@settings[:server]}, checking folders..."
+        folders = [ @settings[:scan_folder] ]
+        folders << @settings[:move_to_folder] unless @settings[:move_to_folder].blank?
+        folders << @settings[:move_invalid_to_folder] unless @settings[:move_invalid_to_folder].blank?
+
+        # Open (or create) destination folder in read-write mode.
+        folders.each do |folder|
+          if @imap.list("", folder)
+            log "folder #{folder} OK"
+          else
+            log "folder #{folder} missing, creating..."
+            @imap.create(folder)
+          end
+        end
+      rescue => e
+        $stderr.puts "setup error #{e.inspect}"
+      ensure
+        disconnect!
+      end
+
+      #--------------------------------------------------------------------------------------
+      def run(dry_run = false)
+        if @dry_run = dry_run
+          log "Not discarding or archiving any new messages..."
+        end
+        connect! or return nil
+        with_new_emails do |uid, email|
+          # Subclasses must define a #process method that takes arguments: uid, email
+          process(uid, email)
+          archive(uid)
+        end
+      ensure
+        log "messages processed=#{@archived + @discarded} archived=#{@archived} discarded=#{@discarded}"
+        disconnect!
+      end
+
+      private
+
+      # Connects to the imap server with the loaded settings
+      #------------------------------------------------------------------------------
+      def connect!(options = {})
+        log "connecting & logging in to #{@settings[:server]}..."
+        @imap = Net::IMAP.new(@settings[:server], @settings[:port], @settings[:ssl])
+        @imap.login(@settings[:user], @settings[:password])
+        log "logged in to #{@settings[:server]}, checking folders..."
+        @imap.select(@settings[:scan_folder]) unless options[:setup]
+        @imap
+      rescue Exception => e
+        $stderr.puts "Could not login to the IMAP server: #{e.inspect}" unless Rails.env == "test"
+        nil
+      end
+
+      #------------------------------------------------------------------------------
+      def disconnect!
+        if @imap
+          @imap.logout
+          unless @imap.disconnected?
+            @imap.disconnect rescue nil
+          end
+        end
+      end
+
+      #--------------------------------------------------------------------------------------
+      def with_new_emails
+        @imap.uid_search(['NOT', 'SEEN']).each do |uid|
+          begin
+            email = Mail.new(@imap.uid_fetch(uid, 'RFC822').first.attr['RFC822'])
+            log "fetched new message...", email
+            if is_valid?(email) && sent_from_known_user?(email)
+              yield(uid, email)
+            else
+              discard(uid)
+            end
+          rescue Exception => e
+            if ["test", "development"].include?(Rails.env)
+              $stderr.puts e
+              $stderr.puts e.backtrace
+            end
+            log "error processing email: #{e.inspect}", email
+            discard(uid)
+          end
+
+          if @dry_run
+            log "Marking message as unread"
+            @imap.uid_store(uid, "-FLAGS", [:Seen])
+          end
+        end
+      end
+
+
+      # Discard message (not valid) action based on settings
+      #------------------------------------------------------------------------------
+      def discard(uid)
+        if @dry_run
+          log "Not discarding message"
+        else
+          if @settings[:move_invalid_to_folder]
+            @imap.uid_copy(uid, @settings[:move_invalid_to_folder])
+          end
+          @imap.uid_store(uid, "+FLAGS", [:Deleted])
+        end
+        @discarded += 1
+      end
+
+      # Archive message (valid) action based on settings
+      #------------------------------------------------------------------------------
+      def archive(uid)
+        if @dry_run
+          log "Not archiving message"
+        else
+          if @settings[:move_to_folder]
+            @imap.uid_copy(uid, @settings[:move_to_folder])
+          end
+          @imap.uid_store(uid, "+FLAGS", [:Seen])
+        end
+        @archived += 1
+      end
+
+      #------------------------------------------------------------------------------
+      def is_valid?(email)
+        valid = email.content_type != "text/html"
+        log("not a text message, discarding") unless valid
+        valid
+      end
+
+      #------------------------------------------------------------------------------
+      def sent_from_known_user?(email)
+        email_address = email.from.first
+        known = !find_sender(email_address).nil?
+        log("sent by unknown user #{email_address}, discarding") unless known
+        known
+      end
+
+      #------------------------------------------------------------------------------
+      def find_sender(email_address)
+        if @sender = User.first(:conditions => [ "(lower(email) = ? OR lower(alt_email) = ?) AND suspended_at IS NULL", email_address.downcase, email_address.downcase ])
+          # Set the PaperTrail user for versions (if user is found)
+          PaperTrail.whodunnit = @sender.id.to_s
+        end
+      end
+
+      #--------------------------------------------------------------------------------------
+      def sender_has_permissions_for?(asset)
+        return true if asset.access == "Public"
+        return true if asset.user_id == @sender.id || asset.assigned_to == @sender.id
+        return true if asset.access == "Shared" && Permission.where('user_id = ? AND asset_id = ? AND asset_type = ?', @sender.id, asset.id, asset.class.to_s).count > 0
+
+        false
+      end
+
+      # Centralized logging.
+      #--------------------------------------------------------------------------------------
+      def log(message, email = nil)
+        unless %w(test cucumber).include?(Rails.env)
+          klass = self.class.to_s.split("::").last
+          klass << " [Dry Run]" if @dry_run
+          puts "[#{Time.now.rfc822}] #{klass}: #{message}"
+          puts "[#{Time.now.rfc822}] #{klass}: From: #{email.from}, Subject: #{email.subject} (#{email.message_id})" if email
+        end
+      end
+
+      # Returns the plain-text version of an email, or strips html tags
+      # if only html is present.
+      #--------------------------------------------------------------------------------------
+      def plain_text_body(email)
+
+        # Extract all parts including nested
+        parts = if email.multipart?
+          email.parts.map {|p| p.multipart? ? p.parts : p}.flatten
+        else
+          [email]
+        end
+
+        if text_part = parts.detect {|p| p.content_type.include?('text/plain')}
+          text_body = text_part.body.to_s
+
+        else
+          html_part = parts.detect {|p| p.content_type.include?('text/html')} || email
+          text_body = Premailer.new(html_part.body.to_s, :with_html_string => true).to_plain_text
+        end
+
+        # Standardize newline
+        text_body.strip.gsub "\r\n", "\n"
+      end
+
+    end
+  end
+end

data/lib/fat_free_crm/mail_processor/comment_replies.rb

@@ -0,0 +1,86 @@
+# 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/>.
+#------------------------------------------------------------------------------
+
+require 'fat_free_crm/mail_processor/base'
+
+module FatFreeCRM
+  module MailProcessor
+    class CommentReplies < Base
+
+      # Subject line of email can contain full entity, or shortcuts
+      # e.g. [contact:1234] OR [co:1234]
+      ENTITY_SHORTCUTS = {
+        'ac' => 'account',
+        'ca' => 'campaign',
+        'co' => 'contact',
+        'le' => 'lead',
+        'op' => 'opportunity',
+        'ta' => 'task'
+      }
+
+      #--------------------------------------------------------------------------------------
+      def initialize
+        @settings = Setting.email_comment_replies.dup
+        super
+      end
+
+      private
+
+      # Email processing pipeline
+      #--------------------------------------------------------------------------------------
+      def process(uid, email)
+        with_subject_line(email) do |entity_name, entity_id|
+          create_comment email, entity_name, entity_id
+        end
+      end
+
+
+      # Checks the email to detect [entity:id] in the subject.
+      #--------------------------------------------------------------------------------------
+      def with_subject_line(email)
+        if /\[([^:]*):([^\]]*)\]/ =~ email.subject
+          entity_name, entity_id = $1, $2
+          # Check that entity is a known model
+          if ENTITY_SHORTCUTS.values.include?(entity_name)
+            yield entity_name, entity_id
+          # Check if entity is a 2 letter 'shortcut'
+          elsif expanded_entity = ENTITY_SHORTCUTS[entity_name]
+            yield expanded_entity, entity_id
+          end
+        end
+      end
+
+
+      # Creates a new comment on an entity
+      #--------------------------------------------------------------------------------------
+      def create_comment(email, entity_name, entity_id)
+        # Find entity from subject params
+        if (entity = entity_name.capitalize.constantize.find_by_id(entity_id))
+          # Create comment if sender has permissions for entity
+          if sender_has_permissions_for?(entity)
+            parsed_reply = EmailReplyParser.parse_reply(plain_text_body(email))
+            Comment.create :user        => @sender,
+                           :commentable => entity,
+                           :comment     => parsed_reply
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/lib/fat_free_crm/mail_processor/dropbox.rb

@@ -0,0 +1,288 @@
+# 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/>.
+#------------------------------------------------------------------------------
+
+require 'fat_free_crm/mail_processor/base'
+
+module FatFreeCRM
+  module MailProcessor
+    class Dropbox < Base
+      KEYWORDS = %w(account campaign contact lead opportunity).freeze
+
+      #--------------------------------------------------------------------------------------
+      def initialize
+        # Models are autoloaded, so the following @@assets class variable should only be set
+        # when Dropbox is initialized. This needs to be done so that Rake tasks such as
+        # 'assets:precompile' can run on Heroku without depending on a database.
+        # See: http://devcenter.heroku.com/articles/rails31_heroku_cedar#troubleshooting
+        @@assets = [ Account, Contact, Lead ].freeze
+        @settings = Setting.email_dropbox.dup
+        super
+      end
+
+      private
+
+      # Email processing pipeline: each steps gets executed if previous one returns false.
+      #--------------------------------------------------------------------------------------
+      def process(uid, email)
+        with_explicit_keyword(email) do |keyword, name|
+          data = {"Type" => keyword, "Name" => name}
+          find_or_create_and_attach(email, data)
+        end and return
+
+        with_recipients(email) do |recipient|
+          find_and_attach(email, recipient)
+        end and return
+
+        with_forwarded_recipient(email) do |recipient|
+          find_and_attach(email, recipient)
+        end and return
+
+        with_recipients(email) do |recipient|
+          create_and_attach(email, recipient)
+        end and return
+
+        with_forwarded_recipient(email) do |recipient|
+          create_and_attach(email, recipient)
+        end
+      end
+
+
+      # Checks the email to detect keyword on the first line.
+      #--------------------------------------------------------------------------------------
+      def with_explicit_keyword(email)
+        first_line = plain_text_body(email).split("\n").first
+        if first_line =~ %r|(#{KEYWORDS.join('|')})[^a-zA-Z0-9]+(.+)$|i
+          yield $1.capitalize, $2.strip
+        end
+      end
+
+      # Checks the email to detect assets on to/bcc addresses
+      #--------------------------------------------------------------------------------------
+      def with_recipients(email, options = {})
+        recipients = []
+        recipients += email.to_addrs unless email.to.blank?
+        recipients += email.cc_addrs unless email.cc.blank?
+
+        # Ignore the dropbox email address, and any address aliases
+        ignored_addresses = [ @settings[:address] ]
+        if @settings[:address_aliases].is_a?(Array)
+          ignored_addresses += @settings[:address_aliases]
+        end
+        recipients -= ignored_addresses
+
+        # Process each recipient until email has been attached
+        recipients.each do |recipient|
+          return true if yield recipient
+        end
+        false
+      end
+
+      # Checks the email to detect valid email address in body (first email), detect forwarded emails
+      #----------------------------------------------------------------------------------------
+      def with_forwarded_recipient(email, options = {})
+        if plain_text_body(email) =~ /\b([a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,4})\b/
+          yield $1
+        end
+      end
+
+      # Process pipe_separated_data or explicit keyword.
+      #--------------------------------------------------------------------------------------
+      def find_or_create_and_attach(email, data)
+        klass = data["Type"].constantize
+
+        if data["Email"] && klass.new.respond_to?(:email)
+          conditions = [
+            "(lower(email) = ? OR lower(alt_email) = ?)",
+            data["Email"].downcase,
+            data["Email"].downcase
+          ]
+        elsif klass.new.respond_to?(:first_name)
+          first_name, *last_name = data["Name"].split
+          conditions = if last_name.empty? # Treat single name as last name.
+            [ 'last_name LIKE ?', "%#{first_name}" ]
+          else
+            [ 'first_name LIKE ? AND last_name LIKE ?', "%#{first_name}", "%#{last_name.join(' ')}" ]
+          end
+        else
+          conditions = ['name LIKE ?', "%#{data["Name"]}%"]
+        end
+
+        # Find the asset from deduced conditions
+        if asset = klass.where(conditions).first
+          if sender_has_permissions_for?(asset)
+            attach(email, asset, :strip_first_line)
+          else
+            log "Sender does not have permissions to attach email to #{data["Type"]} #{data["Email"]} <#{data["Name"]}>"
+          end
+        else
+          log "#{data["Type"]} #{data["Email"]} <#{data["Name"]}> not found, creating new one..."
+          asset = klass.create!(default_values(klass, data))
+          attach(email, asset, :strip_first_line)
+        end
+        true
+      end
+
+      #----------------------------------------------------------------------------------------
+      def find_and_attach(email, recipient)
+        attached = false
+        @@assets.each do |klass|
+          asset = klass.where(["(lower(email) = ?)", recipient.downcase]).first
+
+          # Leads and Contacts have an alt_email: try it if lookup by primary email has failed.
+          if !asset && klass.column_names.include?("alt_email")
+            asset = klass.where(["(lower(alt_email) = ?)", recipient.downcase]).first
+          end
+
+          if asset && sender_has_permissions_for?(asset)
+            attach(email, asset)
+            attached = true
+          end
+        end
+        attached
+      end
+
+      #----------------------------------------------------------------------------------------
+      def create_and_attach(email, recipient)
+        contact = Contact.create!(default_values_for_contact(email, recipient))
+        attach(email, contact)
+      end
+
+      #----------------------------------------------------------------------------------------
+      def attach(email, asset, strip_first_line=false)
+        # If 'sent_to' email cannot be found, default to Dropbox email address
+        to = email.to.blank? ? @settings[:address] : email.to.join(", ")
+        cc = email.cc.blank? ? nil : email.cc.join(", ")
+
+        email_body = if strip_first_line
+          plain_text_body(email).split("\n")[1..-1].join("\n").strip
+        else
+          plain_text_body(email)
+        end
+
+        Email.create(
+          :imap_message_id => email.message_id,
+          :user            => @sender,
+          :mediator        => asset,
+          :sent_from       => email.from.first,
+          :sent_to         => to,
+          :cc              => cc,
+          :subject         => email.subject,
+          :body            => email_body,
+          :received_at     => email.date,
+          :sent_at         => email.date
+        )
+        asset.touch
+
+        if asset.is_a?(Lead) && asset.status == "new"
+          asset.update_attribute(:status, "contacted")
+        end
+
+        if @settings[:attach_to_account] && asset.respond_to?(:account) && asset.account
+          Email.create(
+            :imap_message_id => email.message_id,
+            :user            => @sender,
+            :mediator        => asset.account,
+            :sent_from       => email.from.first,
+            :sent_to         => to,
+            :cc              => cc,
+            :subject         => email.subject,
+            :body            => email_body,
+            :received_at     => email.date,
+            :sent_at         => email.date
+          )
+          asset.account.touch
+        end
+      end
+
+      #----------------------------------------------------------------------------------------
+      def default_values(klass, data)
+        data = data.dup
+        keyword = data.delete("Type").capitalize
+
+        defaults = {
+          :user   => @sender,
+          :access => default_access
+        }
+
+        case keyword
+        when "Account", "Campaign", "Opportunity"
+          defaults[:status] = "planned" if keyword == "Campaign"      # TODO: I18n
+          defaults[:stage] = "prospecting" if keyword == "Opportunity" # TODO: I18n
+
+        when "Contact", "Lead"
+          first_name, *last_name = data.delete("Name").split(' ')
+          defaults[:first_name] = first_name
+          defaults[:last_name] = (last_name.any? ? last_name.join(" ") : "(unknown)")
+          defaults[:status] = "contacted" if keyword == "Lead"        # TODO: I18n
+        end
+
+        data.each do |key, value|
+          key = key.downcase
+          defaults[key.to_sym] = value if klass.new.respond_to?(key + '=')
+        end
+
+        defaults
+      end
+
+      #----------------------------------------------------------------------------------------
+      def default_values_for_contact(email, recipient)
+        recipient_local, recipient_domain = recipient.split('@')
+
+        defaults = {
+          :user       => @sender,
+          :first_name => recipient_local.capitalize,
+          :last_name  => "(unknown)",
+          :email      => recipient,
+          :access     => default_access
+        }
+
+        # Search for domain name in Accounts.
+        account = Account.where('(lower(email) like ? OR lower(website) like ?)', "%#{recipient_domain.downcase}", "%#{recipient_domain.downcase}%").first
+        if account
+          log "asociating new contact #{recipient} with the account #{account.name}"
+          defaults[:account] = account
+        else
+          log "creating new account #{recipient_domain.capitalize} for the contact #{recipient}"
+          defaults[:account] = Account.create!(
+            :user   => @sender,
+            :email  => recipient,
+            :name   => recipient_domain.capitalize,
+            :access => default_access
+          )
+        end
+        defaults
+      end
+
+      # If default access is 'Shared' then change it to 'Private' because we don't know how
+      # to choose anyone to share it with here.
+      #--------------------------------------------------------------------------------------
+      def default_access
+        Setting.default_access == "Shared" ? 'Private' : Setting.default_access
+      end
+
+
+      # Notify users with the results of the operations
+      #--------------------------------------------------------------------------------------
+      def notify(email, mediator_links)
+        DropboxMailer.create_dropbox_notification(
+          @sender, @settings[:address], email, mediator_links
+        ).deliver
+      end
+
+    end
+  end
+end