mailboxer 0.0.8 → 0.0.9

data/app/models/conversation.rb

@@ -0,0 +1,102 @@
+class Conversation < ActiveRecord::Base
+  attr_reader :originator, :original_message, :last_sender, :last_message, :users
+  has_many :messages
+  has_many :receipts, :through => :messages
+  #  before_create :clean
+  scope :participant, lambda {|participant|
+    joins(:receipts).select('DISTINCT conversations.*').where('receipts.receiver_id' => participant.id,'receipts.receiver_type' => participant.class.to_s).order("conversations.updated_at DESC")
+  }
+  scope :inbox, lambda {|participant|
+    joins(:receipts).select('DISTINCT conversations.*').where('receipts.receiver_id' => participant.id,'receipts.receiver_type' => participant.class.to_s, 'receipts.mailbox_type' => 'inbox','receipts.trashed' => false).order("conversations.updated_at DESC")
+  }
+  scope :sentbox, lambda {|participant|
+    joins(:receipts).select('DISTINCT conversations.*').where('receipts.receiver_id' => participant.id,'receipts.receiver_type' => participant.class.to_s, 'receipts.mailbox_type' => 'sentbox','receipts.trashed' => false).order("conversations.updated_at DESC")    
+  }
+  scope :trash, lambda {|participant|
+    joins(:receipts).select('DISTINCT conversations.*').where('receipts.receiver_id' => participant.id,'receipts.receiver_type' => participant.class.to_s,'receipts.trashed' => true).order("conversations.updated_at DESC")
+  }
+  scope :unread,  lambda {|participant|
+    joins(:receipts).select('DISTINCT conversations.*').where('receipts.receiver_id' => participant.id,'receipts.receiver_type' => participant.class.to_s,'receipts.read' => false).order("conversations.updated_at DESC")
+  }
+  
+  class << self
+    def total
+      count('DISTINCT conversations.id')
+    end
+  end
+  
+  def mark_as_read(participant)
+    return if participant.nil?
+    return self.receipts(participant).mark_as_read
+  end
+  
+  def mark_as_unread(participant)
+    return if participant.nil?
+    return self.receipts(participant).mark_as_unread
+  end
+  
+  def move_to_trash(participant)
+    return if participant.nil?
+    return self.receipts(participant).move_to_trash
+  end
+  
+  def untrash(participant)
+    return if participant.nil?
+    return self.receipts(participant).untrash
+  end
+  
+  #originator of the conversation.
+  def originator
+    @orignator = self.original_message.sender if @originator.nil?
+    return @orignator
+  end
+  
+  #first message of the conversation.
+  def original_message
+    @original_message = self.messages.find(:first, :order => 'created_at') if @original_message.nil?
+    return @original_message
+  end
+  
+  #sender of the last message.
+  def last_sender
+    @last_sender = self.last_message.sender if @last_sender.nil?
+    return @last_sender
+  end
+  
+  #last message in the conversation.
+  def last_message
+    @last_message = self.messages.find(:first, :order => 'created_at DESC') if @last_message.nil?
+    return @last_message
+  end
+  
+  def receipts(participant=nil)
+    return Receipt.conversation(self).receiver(participant) if participant
+    return Receipt.conversation(self)
+  end
+  
+  #all users involved in the conversation.
+  def recipients
+    return last_message.get_recipients
+  end
+  
+  def get_recipients
+    return self.recipients
+  end
+  
+  def count_messages
+    return Message.conversation(self).count
+  end
+  
+  def is_participant?(participant)
+    return false if participant.nil?
+    return self.receipts(participant).count != 0
+  end
+  #  protected
+  #  #[empty method]
+  #  #
+  #  #this gets called before_create. Implement this if you wish to clean out illegal content such as scripts or anything that will break layout. This is left empty because what is considered illegal content varies.
+  #  def clean
+  #    return if subject.nil?
+  #    #strip all illegal content here. (scripts, shit that will break layout, etc.)
+  #  end
+end

data/app/models/{mailboxer_mailbox.rb → mailbox.rb}

@@ -1,9 +1,6 @@
-class MailboxerMailbox
-  #this is used to filter mail by mailbox type, use the [] method rather than setting this directly.
+class Mailbox
   attr_accessor :type
-  #the user/owner of this mailbox, set when initialized.
   attr_reader :messageable
-  #creates a new Mailbox instance with the given user and optional type.
   
   def initialize(recipient, box = :all)
     @messageable = recipient
@@ -15,16 +12,16 @@ class MailboxerMailbox
   end
   
   def conversations(options = {})
-    conv = MailboxerConversation.participant(@messageable)
+    conv = Conversation.participant(@messageable)
     
     if options[:mailbox_type].present?
       case options[:mailbox_type]
         when 'inbox'
-        conv = MailboxerConversation.inbox(@messageable)
+        conv = Conversation.inbox(@messageable)
         when 'sentbox'
-        conv = MailboxerConversation.sentbox(@messageable)
+        conv = Conversation.sentbox(@messageable)
         when 'trash'
-        conv = MailboxerConversation.trash(@messageable)
+        conv = Conversation.trash(@messageable)
       end      
     end
     
@@ -50,8 +47,8 @@ class MailboxerMailbox
     return self.conversations(options)     
   end
   
-  def mail(options = {})
-    return MailboxerMail.where(options).receiver(@messageable)
+  def receipts(options = {})
+    return Receipt.where(options).receiver(@messageable)
   end
   
   def [](mailbox_type)
@@ -64,28 +61,28 @@ class MailboxerMailbox
   end
   
   def add(msg)
-    mail_msg = MailboxerMail.new
-    mail_msg.mailboxer_message = msg
-    mail_msg.read = (msg.sender.id == @messageable.id && msg.sender.class == @messageable.class)
-    mail_msg.receiver = @messageable
-    mail_msg.mailbox_type = @type.to_s unless @type == :all
-    @messageable.mailboxer_mails << mail_msg
-    return mail_msg
+    msg_receipt = Receipt.new
+    msg_receipt.message = msg
+    msg_receipt.read = (msg.sender.id == @messageable.id && msg.sender.class == @messageable.class)
+    msg_receipt.receiver = @messageable
+    msg_receipt.mailbox_type = @type.to_s unless @type == :all
+    @messageable.receipts << msg_receipt
+    return msg_receipt
   end
   
   def empty_trash(options = {})
-    return self.mail.trash(options).delete_all
+    return false
   end
   
   def has_conversation?(conversation)
-    return self.mail.conversation(converstaion).count!=0
+    return self.receipts.conversation(converstaion).count!=0
   end
   
   def is_trashed?(conversation)
-    return self.mail.trash.conversation(conversation).count!=0
+    return self.receipts.trash.conversation(conversation).count!=0
   end
   def is_completely_trashed?(conversation)
-    return self.mail.trash.conversation(conversation).count==self.mail.conversation(conversation).count
+    return self.receipts.trash.conversation(conversation).count==self.receipts.conversation(conversation).count
   end
   
 end

data/app/models/{mailboxer_message.rb → message.rb}

@@ -1,4 +1,4 @@
-class MailboxerMessage < ActiveRecord::Base
+class Message < ActiveRecord::Base
   #any additional info that needs to be sent in a message (ex. I use these to determine request types)
   serialize :headers
   
@@ -9,10 +9,10 @@ class MailboxerMessage < ActiveRecord::Base
   class_inheritable_accessor :on_deliver_clean
   protected :on_deliver_clean
   belongs_to :sender, :polymorphic => :true
-  belongs_to :mailboxer_conversation
-  has_many :mailboxer_mails
+  belongs_to :conversation
+  has_many :receipts
   scope :conversation, lambda { |conversation|    
-    where(:mailboxer_conversation_id => conversation.id)
+    where(:conversation_id => conversation.id)
   }
     
   class << self
@@ -33,18 +33,10 @@ class MailboxerMessage < ActiveRecord::Base
   
   def get_recipients
     recipients_array = Array.new 
-    self.mailboxer_mails.each do |mail|      
-      recipients_array << mail.receiver
+    self.receipts.each do |receipt|      
+      recipients_array << receipt.receiver
     end
     return recipients_array.uniq
   end
   
-  def conversation
-    self.mailboxer_conversation
-  end
-  
-  def mails
-    self.mailboxer_mails
-  end
-  
 end

data/app/models/{mailboxer_mail.rb → receipt.rb}

@@ -1,15 +1,15 @@
-class MailboxerMail < ActiveRecord::Base
-  belongs_to :mailboxer_message
-  has_one :mailboxer_conversation, :through => :mailboxer_message
+class Receipt < ActiveRecord::Base
+  belongs_to :message
+  has_one :conversation, :through => :message
   belongs_to :receiver, :polymorphic => :true
   scope :receiver, lambda { |receiver|
     where(:receiver_id => receiver.id,:receiver_type => receiver.class.to_s)
   }
   scope :message, lambda { |message|
-    where(:mailboxer_message_id => message.id)
+    where(:message_id => message.id)
   }
   scope :conversation, lambda { |conversation|    
-    joins(:mailboxer_message).where('mailboxer_messages.mailboxer_conversation_id' => conversation.id)
+    joins(:message).where('messages.conversation_id' => conversation.id)
   }
   scope :sentbox, where(:mailbox_type => "sentbox")
   scope :inbox, where(:mailbox_type => "inbox")
@@ -66,13 +66,5 @@ class MailboxerMail < ActiveRecord::Base
   def move_to_sentbox
     update_attributes(:mailbox_type => :sentbox, :trashed => false)
   end
-  
-  def message
-    self.mailboxer_message
-  end
-  
-  def conversation
-    self.mailboxer_conversation
-  end
-  
+
 end

data/lib/generators/mailboxer/templates/migration.rb

@@ -1,13 +1,13 @@
 class CreateMailboxer < ActiveRecord::Migration
   def self.up    
-    create_table :mailboxer_conversations do |t|
+    create_table :conversations do |t|
       t.column :subject, :string, :default => ""
       t.column :created_at, :datetime, :null => false
       t.column :updated_at, :datetime, :null => false
     end    
-    create_table :mailboxer_mails do |t|
+    create_table :receipts do |t|
       t.references :receiver, :polymorphic => true
-      t.column :mailboxer_message_id, :integer, :null => false
+      t.column :message_id, :integer, :null => false
       t.column :read, :boolean, :default => false
       t.column :trashed, :boolean, :default => false
       t.column :deleted, :boolean, :default => false
@@ -15,12 +15,12 @@ class CreateMailboxer < ActiveRecord::Migration
       t.column :created_at, :datetime, :null => false
       t.column :updated_at, :datetime, :null => false
     end    
-    create_table :mailboxer_messages do |t|
+    create_table :messages do |t|
       t.column :body, :text
       t.column :subject, :string, :default => ""
       t.column :headers, :text
       t.references :sender, :polymorphic => true
-      t.column :mailboxer_conversation_id, :integer
+      t.column :conversation_id, :integer
       t.column :sent, :boolean, :default => false
       t.column :draft, :boolean, :default => false
       t.column :system, :boolean, :default => false
@@ -30,8 +30,8 @@ class CreateMailboxer < ActiveRecord::Migration
   end
   
   def self.down
-    drop_table :mailboxer_mails
-    drop_table :mailboxer_conversations
-    drop_table :mailboxer_messages
+    drop_table :receipts
+    drop_table :conversations
+    drop_table :messages
   end
 end

data/lib/mailboxer/models/messageable.rb

@@ -1,93 +1,91 @@
-module Mailboxer 
-  module Models 
-    module Messageable       
-      
-      def self.included(mod)
-        mod.extend(ClassMethods)
-      end
-      
-      module ClassMethods
-        
-        def acts_as_messageable          
-          has_many :mailboxer_messages
-          has_many :mailboxer_mails, :order => 'created_at DESC', :dependent => :delete_all    
-          
-          include Mailboxer::Models::Messageable::InstanceMethods
-        end
-      end
-      
-      module InstanceMethods
-        
-        def mailbox
-          @mailbox = MailboxerMailbox.new(self) if @mailbox.nil?
-          @mailbox.type = :all
-          return @mailbox
-        end
-        
-        def send_message(recipients, msg_body, subject = '')
-          convo = MailboxerConversation.create({:subject => subject})
-          message = MailboxerMessage.create({:sender => self, :mailboxer_conversation => convo,  :body => msg_body, :subject => subject})
-          message.recipients = recipients.is_a?(Array) ? recipients : [recipients]
-          message.deliver(:inbox)
-          return mailbox[:sentbox] << message
-        end
-        
-        def reply(conversation, recipients, reply_body, subject = nil)
-          return nil if(reply_body.blank?)
-          conversation.update_attribute(:updated_at, Time.now)
-          subject = subject || "RE: #{conversation.subject}"
-          response = MailboxerMessage.create({:sender => self, :mailboxer_conversation => conversation, :body => reply_body, :subject => subject})
-          response.recipients = recipients.is_a?(Array) ? recipients : [recipients]
-          response.recipients.delete(self)
-          response.deliver(:inbox)
-          return mailbox[:sentbox] << response
-        end
-        
-        def reply_to_sender(mail, reply_body, subject = nil)
-          return reply(mail.mailboxer_conversation, mail.mailboxer_message.sender, reply_body, subject)
-        end
-        
-        def reply_to_all(mail, reply_body, subject = nil)
-          msg = mail.mailboxer_message
-          recipients = msg.get_recipients
-          return reply(mail.mailboxer_conversation, recipients, reply_body, subject)
-        end
-        
-        def reply_to_conversation(conversation, reply_body, subject = nil)
-          #move conversation to inbox if it is currently in the trash - doesnt make much sense replying to a trashed convo.
-          if(mailbox.is_trashed?(conversation))
-            mailbox.mail.conversation(conversation).untrash
-          end
-          #remove self from recipients unless you are the originator of the convo
-          recipients = conversation.get_recipients
-          if(conversation.originator != self)
-            recipients.delete(self)
-            if(!recipients.include?(conversation.originator))
-              recipients << conversation.originator
-            end
-          end
-          return reply(conversation,recipients, reply_body, subject)
-        end 
-        
-        def read_mail(mail)          
-          return mail.mark_as_read if mail.receiver == self
-        end 
-        
-        def unread_mail(mail)
-          return mail.mark_as_unread if mail.receiver == self
-        end
-        
-        def read_conversation(conversation, options = {})
-          mails = conversation.mailboxer_mails.receiver(self)
-          mails_clone = mails.clone
-          
-          mails.each do |mail|
-            mail.mark_as_read
-          end
-          
-          return mails_clone
-        end
-      end
-    end
-  end
+module Mailboxer
+	module Models
+		module Messageable
+			def self.included(mod)
+				mod.extend(ClassMethods)
+			end
+
+			module ClassMethods
+				def acts_as_messageable
+					has_many :messages
+					has_many :receipts, :order => 'created_at DESC', :dependent => :delete_all
+
+					include Mailboxer::Models::Messageable::InstanceMethods
+				end
+			end
+
+			module InstanceMethods
+				def mailbox
+					@mailbox = Mailbox.new(self) if @mailbox.nil?
+					@mailbox.type = :all
+					return @mailbox
+				end
+
+				def send_message(recipients, msg_body, subject = '')
+					convo = Conversation.create({:subject => subject})
+					message = Message.create({:sender => self, :conversation => convo,  :body => msg_body, :subject => subject})
+					message.recipients = recipients.is_a?(Array) ? recipients : [recipients]
+					message.deliver(:inbox)
+					return mailbox[:sentbox] << message
+				end
+
+				def reply(conversation, recipients, reply_body, subject = nil)
+					return nil if(reply_body.blank?)
+					conversation.update_attribute(:updated_at, Time.now)
+					subject = subject || "RE: #{conversation.subject}"
+					response = Message.create({:sender => self, :conversation => conversation, :body => reply_body, :subject => subject})
+					response.recipients = recipients.is_a?(Array) ? recipients : [recipients]
+					response.recipients.delete(self)
+					response.deliver(:inbox)
+					return mailbox[:sentbox] << response
+				end
+
+				def reply_to_sender(receipt, reply_body, subject = nil)
+					return reply(receipt.conversation, receipt.message.sender, reply_body, subject)
+				end
+
+				def reply_to_all(receipt, reply_body, subject = nil)
+					msg = receipt.message
+					recipients = msg.get_recipients
+					return reply(receipt.conversation, recipients, reply_body, subject)
+				end
+
+				def reply_to_conversation(conversation, reply_body, subject = nil)
+					#move conversation to inbox if it is currently in the trash - doesnt make much sense replying to a trashed convo.
+					if(mailbox.is_trashed?(conversation))
+						mailbox.receipts.conversation(conversation).untrash
+					end
+					#remove self from recipients unless you are the originator of the convo
+					recipients = conversation.get_recipients
+					if(conversation.originator != self)
+						recipients.delete(self)
+						if(!recipients.include?(conversation.originator))
+						recipients << conversation.originator
+						end
+					end
+					return reply(conversation,recipients, reply_body, subject)
+				end
+
+				def read_message(obj)
+					if obj.class.to_s.eql? 'Receipt'
+						return obj.mark_as_read if obj.receiver == self
+					elsif obj.class.to_s.eql? 'Message'
+						receipts = obj.receipts.receiver(self)
+						return receipts.mark_as_read
+					end
+					return nil
+				end
+
+				def unread_message(obj)
+					if obj.class.to_s.eql? 'Receipt'
+						return obj.mark_as_unread if obj.receiver == self
+					elsif obj.class.to_s.eql? 'Message'
+						receipts = obj.receipts.receiver(self)
+						return receipts.mark_as_unread
+					end
+					return nil
+				end
+			end
+		end
+	end
 end