mail_manager 0.0.1

data/app/helpers/mail_manager/application_helper.rb

@@ -0,0 +1,4 @@
+module MailManager
+  module ApplicationHelper
+  end
+end

data/app/helpers/mail_manager/subscriptions_helper.rb

@@ -0,0 +1,8 @@
+module MailManager
+  module SubscriptionsHelper
+    def contactable_subscriptions_selector(contactable_form, default_unsubscribe_status="unsubscribed")
+      render :partial => 'mail_manager/subscriptions/subscriptions', :locals => {:contactable_form => contactable_form,
+        :unsubscribed_status => default_unsubscribe_status}
+    end
+  end
+end

data/app/models/mail_manager.rb

@@ -0,0 +1,12 @@
+module MailManager
+end
+
+require 'mail_manager/bounce'
+require 'mail_manager/mailable_registry'
+require 'mail_manager/mailer'
+require 'mail_manager/mailing'
+require 'mail_manager/mailing_list'
+require 'mail_manager/message'
+require 'mail_manager/contactable_registry'
+require 'mail_manager/subscription'
+require 'mail_manager/contact'

data/app/models/mail_manager/bounce.rb

@@ -0,0 +1,133 @@
+=begin rdoc
+Author::    Chris Hauboldt (mailto:biz@lnstar.com)
+Copyright:: 2009 Lone Star Internet Inc.
+
+Used to record messages which are returned to the configured account for 'bounce' in the config/config.yml, and pulled by BounceJob. Also responsible for knowing how to process a bounce by pulling diagnostic codes and a message's guid from the bounced email, unsubscribing users when necessary.
+
+Diagnostic Codes:
+5xx - will currently unsubscribe a contact, except when the error contains 'quota'
+4xx - is ignored, and marked 'resolved' as they are temporary errors
+
+Statuses:
+'unprocessed' - initial status before processing
+'needs_manual_intervention' - message identified by guid, but message not understood
+'resolved' - message has been resolved during processing, and appropriate action taken
+'invalid' - message not identified
+'dismissed' - bounce has been dismissed by user
+=end
+
+module MailManager
+  class Bounce < ActiveRecord::Base
+    self.table_name = "#{MailManager.table_prefix}bounces"
+    belongs_to :message, :class_name => 'MailManager::Message'
+    belongs_to :mailing, :class_name => 'MailManager::Mailing'
+    include StatusHistory
+    override_statuses(['needs_manual_intervention','unprocessed','dismissed','resolved','invalid'],'unprocessed')
+    before_create :set_default_status
+    default_scope :order => "#{MailManager.table_prefix}contacts.last_name, #{MailManager.table_prefix}contacts.first_name, #{MailManager.table_prefix}contacts.email_address",
+        :joins => 
+        "LEFT OUTER JOIN #{MailManager.table_prefix}messages on #{MailManager.table_prefix}bounces.message_id=#{MailManager.table_prefix}messages.id "+
+        " LEFT OUTER JOIN #{MailManager.table_prefix}contacts on #{MailManager.table_prefix}messages.contact_id=#{MailManager.table_prefix}contacts.id"
+#
+    scope :by_mailing_id, lambda {|mailing_id| where(:mailing_id => mailing_id)}
+    scope :by_status, lambda {|status| where(:status => status.to_s)}
+
+    attr_protected :id
+    #Parses email contents for bounce resolution
+    def process(force=false)
+      if status.eql?('unprocessed') || force
+        self.message = Message.find_by_guid(bounce_message_guid)
+        self.mailing = message.mailing unless message.nil?
+        if !from_mailer_daemon?
+          change_status(:invalid)
+        elsif delivery_error_code =~ /4\.\d\.\d/ || delivery_error_message.to_s =~ /quota/i
+          update_attribute(:comments, delivery_error_message)
+          change_status(:resolved)
+        elsif delivery_error_code =~ /5\.\d\.\d/ && delivery_error_message.present?
+          transaction do 
+            update_attribute(:comments, delivery_error_message)
+            change_status(:resolved)
+            message.change_status(:failed)
+            message.update_attribute(:result,"Failure Message from Bounce: #{delivery_error_message}")
+            Subscription.fail_by_email_address(contact_email_address)
+          end
+        else
+          update_attribute(:comments, 'unrecognized diagnostic code')
+          change_status(:needs_manual_intervention)
+        end
+        save
+      end
+    end
+
+    def reprocess
+      process(true)
+    end
+
+    def from_mailer_daemon?
+      ['postmaster','mailer-daemon'].include?(email.from.first.gsub(/\@.*$/,'').downcase)
+    end
+  
+    def dismiss
+      raise "Status cannot be manually changed unless it needs manual intervention!" unless
+        status.eql?('needs_manual_intervention')
+      change_status(:dismissed)
+    end
+  
+    def fail_address
+      raise "Status cannot be manually changed unless it needs manual intervention!"  unless
+        status.eql?('needs_manual_intervention')
+      transaction do 
+        Subscription.fail_by_email_address(contact_email_address)
+        message.result = message.result.to_s + "Failed by Administrator: (bounced, not auto resolved) "
+        message.change_status(:failed)
+        change_status(:resolved)
+      end
+    end
+
+    def mailing_subject
+      message.try(:mailing).try(:subject)
+    end
+  
+    def subscription
+      message.try(:subscription)
+    end
+    
+    def contact
+      message.try(:contact)
+    end
+  
+    def contact_full_name
+      contact.try(:full_name)
+    end
+
+    def contact_email_address
+      if contact.blank?
+        "Contact Deleted"
+      else
+        contact.email_address
+      end
+    end
+  
+    def delivery_error_code
+      email.error_status
+    rescue
+      nil
+    end
+
+    def delivery_error_message
+      email.diagnostic_code
+    rescue
+      nil
+    end
+
+    # Returns message guid 
+    def bounce_message_guid
+      email.to_s.gsub(/^.*X-Bounce-GUID:\s*([^\s]+).*$/mi,'\1') if email.to_s.match(/X-Bounce-GUID:\s*([^\s]+)/mi)
+    end
+
+    def email
+      return @email if @email
+      @email = Mail.new(bounce_message)
+    end
+  end
+end

data/app/models/mail_manager/contact.rb

@@ -0,0 +1,91 @@
+module MailManager
+  class Contact < ActiveRecord::Base
+    self.table_name =  "#{MailManager.table_prefix}contacts"
+    has_many :messages, :class_name => 'MailManager::Message'
+    
+    belongs_to :contactable, :polymorphic => true
+    #not working for some reasom
+    #accepts_nested_attributes_for :subscriptions
+  
+    validates_presence_of :email_address
+    #validates_format_of :email_address, :with => Authentication.email_regex, 
+    #  :message => Authentication.bad_email_message, :allow_nil => true
+    validates_format_of :email_address, :with => /\w{1,}[@][\w\-]{1,}([.]([\w\-]{1,})){1,3}$/, :allow_nil => true
+
+    include MailManager::ContactableRegistry::Contactable
+    include Deleteable
+
+    attr_protected :id
+
+    def contact
+      self
+    end
+    
+    scope :search, lambda{|params| 
+      conditions = ["deleted_at IS NULL"]
+      joins = {}
+      unless params[:term].blank?
+        conditions[0] += " AND (#{params[:term].split(/\s+/).collect{ |term|
+          term = "%#{term}%";
+          3.times{conditions << term}
+          "(first_name like ? OR last_name like ? OR email_address like ?)"
+        }.join(' OR ')})"
+      end
+
+      if params[:mailing_list_id].present? 
+        joins = {joins: "INNER JOIN #{MailManager.table_prefix}subscriptions s ON
+          s.contact_id=#{MailManager.table_prefix}contacts.id AND s.mailing_list_id=#{params[:mailing_list_id].to_i}"}
+      end
+      unless params[:status].blank? || params[:mailing_list_id].blank?
+        conditions[0] += " AND status=?"
+        conditions << params[:status]
+      end
+      conditions = { 
+        :conditions => conditions, 
+        :order =>  'last_name, first_name, email_address'
+      }
+      conditions.merge!(joins) if params[:mailing_list_id].present?
+      conditions
+    }
+
+    scope :active, lambda {{:conditions => "#{table_name}.deleted_at IS NULL"}}
+  
+    default_scope :order => 'last_name, first_name, email_address'
+
+    def email_address_with_name
+      return %Q|"#{full_name}" <#{email_address}>|.gsub(/\s+/,' ') unless full_name.eql?('')
+      email_address
+    end
+
+    def full_name
+      "#{first_name} #{last_name}".strip
+    end
+
+    def deleted?
+      !deleted_at.nil?
+    end
+
+    def self.signup(params)
+      contact = MailManager::Contact.active.find_by_email_address(params['email_address']) 
+      contact ||= Contact.new
+      Rails.logger.debug "Updating contact(#{contact.new_record? ? "New" : contact.id}) params: #{params.inspect}"
+      contact.update_attributes(params)
+      contact
+    end
+        
+    def initialize_subscriptions
+      @subscriptions = new_record? ? [] : Subscription.find_all_by_contact_id(self.id) 
+      MailingList.active.each do |list|
+        next if @subscriptions.detect{|subscription| subscription.mailing_list_id.eql?(list.id) }
+        Rails.logger.warn "Building Subscription for Mailing List #{list.name}"
+        subscription = Subscription.new(:contact => self)
+        subscription.mailing_list_id = list.id 
+        subscription.change_status((self.new_record? and list.defaults_to_active?) ? :active : :pending,false)
+        @subscriptions << subscription
+      end
+      @subscriptions = subscriptions.reject{|subscription| subscription.mailing_list.try(:inactive?) or
+        subscription.mailing_list.nil?}.sort_by{|subscription|
+        subscription.mailing_list.name.downcase}
+    end
+  end
+end

data/app/models/mail_manager/contactable_registry.rb

@@ -0,0 +1,190 @@
+module MailManager
+  class ContactableRegistry
+    
+    @@contactable_things = {}
+    def self.register_contactable(classname, methods={})
+      @@contactable_things.merge!(classname => methods)
+      Rails.logger.warn "Registered Contactable: #{classname}"
+      Rails.logger.debug "Current Contactables: #{@@contactable_things.inspect}"
+    end
+    
+    def self.registered_methods(classname=nil)
+      return @@contactable_things[classname.to_s].keys unless classname.nil?
+      all_methods = {}
+      @@contactable_things.values.each do |methods|
+        all_methods.merge!(methods)
+      end
+      all_methods.keys.reject{|key| key.to_s.eql?('edit_route')}
+    end
+    
+    def self.valid_contactable_substitutions(classname=nil)
+      registered_methods(classname).collect{|key| key.to_s.upcase}
+    end
+  
+    def self.contactable_method(classname,method)
+      @@contactable_things[classname][method] || method
+    end
+
+    def self.edit_route_for(classname)
+      return @@contactable_things[classname][:edit_route] if @@contactable_things[classname][:edit_route].present?
+      "edit_#{classname.underscore}_path"
+    end
+    
+    module Contactable
+
+      #FIXME: this is NOT secure!!!!
+      def update_contactable_data
+        set_contactable_data && self.contact.save
+      end
+      def set_contactable_data
+        unless self.is_a?(MailManager::Contact)
+          if self.contact.present?
+            self.contact.update_attributes(
+              :first_name => contactable_value(:first_name).to_s,
+              :last_name => contactable_value(:last_name).to_s,
+              :email_address => contactable_value(:email_address).to_s)
+          else
+            self.contact = Contact.new(
+              :contactable => self,
+              :first_name => contactable_value(:first_name).to_s,
+              :last_name => contactable_value(:last_name).to_s,
+              :email_address => contactable_value(:email_address).to_s
+            )
+          end
+        end
+        self.contact.present? and self.contact.errors.empty?
+      end
+      
+      def initialize_subscriptions
+        if self.contact.nil?
+          self.contact = MailManager::Contact.new(
+            :first_name => contactable_value(:first_name).to_s,
+            :last_name => contactable_value(:last_name).to_s,
+            :email_address => contactable_value(:email_address).to_s)
+        end
+        self.contact.initialize_subscriptions
+      end
+
+      def subscription_status_for(mailing_list)
+        subscriptions.detect{|subscription| subscription.mailing_list_id.eql?(mailing_list.id)}.status
+      end
+
+      def update_subscription_data
+        Rails.logger.debug "Updating Subscriptions: #{@subscriptions_attributes.inspect} - #{subscriptions.inspect}"
+        subscriptions.each do |subscription|
+          Rails.logger.debug "Updating Subscription attributes for: #{subscription.inspect}"
+          unless @subscriptions_attributes.nil?
+            subscription_attributes = get_subscription_atttributes_for_subscription(subscription)
+            if subscription.new_record? and subscription_attributes[:status] != 'active'
+              Rails.logger.debug "Skipping new subscription save, since we're not subscribing"
+              subscription.change_status(subscription_attributes[:status],false)
+              #mucking with the array messes up the each!
+              #subscriptions.delete_if{|my_subscription| my_subscription.mailing_list_id == subscription.mailing_list_id}
+            elsif subscription_attributes[:status].present?
+              Rails.logger.debug "Changing from #{subscription.status} to #{subscription_attributes[:status]}"
+              subscription.change_status(subscription_attributes[:status])
+            end
+          end
+        end
+        true
+      end
+      
+      def get_subscription_atttributes_for_subscription(subscription)
+        return {} if @subscriptions_attributes.nil?
+        subscriptions_attributes.values.detect{|subscription_attributes| 
+          subscription_attributes[:mailing_list_id].to_i == subscription.mailing_list_id.to_i} || {}
+      end
+
+      def subscribe(mailing_list)
+        set_contactable_data && MailManager::Subscription.subscribe(contact,mailing_list)
+      end
+
+      def unsubscribe(mailing_list)
+        set_contactable_data && MailManager::Subscription.unsubscribe(contact,mailing_list)
+      end
+
+      def change_subscription_status(mailing_list,status)
+        set_contactable_data && MailManager::Subscription.change_subscription_status(contact,mailing_list,status)
+      end
+
+      def contactable_value(method)
+        begin
+          send(contactable_method(method.to_sym))
+        rescue => e
+          nil
+        end
+      end
+
+      def contactable_method(method)
+        begin
+          MailManager::ContactableRegistry.contactable_method(self.class.name,method.to_sym)
+        rescue => e
+          method
+        end
+      end
+      
+      def reload
+        @subscriptions = nil
+      end
+      
+      def subscriptions
+        return @subscriptions unless @subscriptions.nil?
+        set_contactable_data unless self.contact.present?
+        @subscriptions = contact.initialize_subscriptions
+      end
+      
+      def active_subscriptions
+        subscriptions.select{|subscription| subscription.active?}
+      end
+      
+      def save(*args)
+        success = true
+        if args[0] != false
+          begin 
+            transaction do 
+              success = success && super
+              if self.contactable_value(:email_address).present?
+                Rails.logger.debug "User save super success? #{success.inspect}"
+                success = update_subscription_data && success
+                Rails.logger.debug "User save subscription data success? #{success.inspect}"
+                success = update_contactable_data unless (!success or self.is_a?(MailManager::Contact))
+                Rails.logger.debug "User save contactable data success? #{success.inspect}"
+              end
+              raise "Failed to update contactable and/or #{self.class.name} data." unless success
+            end
+          rescue => e
+            Rails.logger.debug "User save failed! #{e.message} #{e.backtrace.join("\n  ")}"
+          end
+          Rails.logger.debug "User save successful? #{success}"
+        else
+          success = super
+        end
+        success
+      end
+
+      module Associations
+        def self.included(model)
+          model.class_eval do
+            has_one :contact, :as => :contactable, :class_name => 'MailManager::Contact'
+            #overloading with some extra stuff is better than this
+            #has_many :subscriptions, :through => :contact, :class_name => 'MailManager::Subscription'
+          end
+        end
+      end
+
+      module AttrAccessors
+        def self.included(model)
+          model.class_eval do
+            after_create :save
+            attr_accessor :subscriptions_attributes
+          end
+        end
+      end
+      
+      def self.included(model)
+        model.send(:include, Associations)
+        model.send(:include, AttrAccessors)
+      end
+    end
+  end
+end