mailboxer-without-notification 0.11.1

data/app/models/mailbox.rb

@@ -0,0 +1,122 @@
+class Mailbox
+  attr_accessor :type
+  attr_reader :messageable
+
+  #Initializer method
+  def initialize(messageable)
+    @messageable = messageable
+  end
+
+  #Returns the notifications for the messageable
+  def notifications(options = {})
+    #:type => nil is a hack not to give Messages as Notifications
+    notifs = Message.recipient(@messageable).order("messages.created_at DESC")
+    if (options[:read].present? and options[:read]==false) or (options[:unread].present? and options[:unread]==true)
+      notifs = notifs.unread
+    end
+
+    notifs
+  end
+
+  #Returns the conversations for the messageable
+  #
+  #Options
+  #
+  #* :mailbox_type
+  #  * "inbox"
+  #  * "sentbox"
+  #  * "trash"
+  #
+  #* :read=false
+  #* :unread=true
+  #
+  def conversations(options = {})
+    conv = Conversation.participant(@messageable)
+
+    if options[:mailbox_type].present?
+      case options[:mailbox_type]
+      when 'inbox'
+        conv = Conversation.inbox(@messageable)
+      when 'sentbox'
+        conv = Conversation.sentbox(@messageable)
+      when 'trash'
+        conv = Conversation.trash(@messageable)
+      when  'not_trash'
+        conv = Conversation.not_trash(@messageable)
+      end
+    end
+
+    if (options.has_key?(:read) && options[:read]==false) || (options.has_key?(:unread) && options[:unread]==true)
+      conv = conv.unread(@messageable)
+    end
+
+    conv
+  end
+
+  #Returns the conversations in the inbox of messageable
+  #
+  #Same as conversations({:mailbox_type => 'inbox'})
+  def inbox(options={})
+    options = options.merge(:mailbox_type => 'inbox')
+    self.conversations(options)
+  end
+
+  #Returns the conversations in the sentbox of messageable
+  #
+  #Same as conversations({:mailbox_type => 'sentbox'})
+  def sentbox(options={})
+    options = options.merge(:mailbox_type => 'sentbox')
+    self.conversations(options)
+  end
+
+  #Returns the conversations in the trash of messageable
+  #
+  #Same as conversations({:mailbox_type => 'trash'})
+  def trash(options={})
+    options = options.merge(:mailbox_type => 'trash')
+    self.conversations(options)
+  end
+
+  #Returns all the receipts of messageable, from Messages and Notifications
+  def receipts(options = {})
+    Receipt.where(options).recipient(@messageable)
+  end
+
+  #Deletes all the messages in the trash of messageable. NOT IMPLEMENTED.
+  def empty_trash(options = {})
+    #TODO
+    false
+  end
+
+  #Returns if messageable is a participant of conversation
+  def has_conversation?(conversation)
+    conversation.is_participant?(@messageable)
+  end
+
+  #Returns true if messageable has at least one trashed message of the conversation
+  def is_trashed?(conversation)
+    conversation.is_trashed?(@messageable)
+  end
+
+  #Returns true if messageable has trashed all the messages of the conversation
+  def is_completely_trashed?(conversation)
+    conversation.is_completely_trashed?(@messageable)
+  end
+
+  #Returns the receipts of object for messageable as a ActiveRecord::Relation
+  #
+  #Object can be:
+  #* A Message
+  #* A Notification
+  #* A Conversation
+  #
+  #If object isn't one of the above, a nil will be returned
+  def receipts_for(object)
+    case object
+    when Message#, Notification
+      object.receipt_for(@messageable)
+    when Conversation
+      object.receipts_for(@messageable)
+    end
+  end
+end

data/app/models/message.rb

@@ -0,0 +1,218 @@
+class Message < ActiveRecord::Base
+  #AJOUT DEPUIS NOTIFICATION
+  attr_accessor :recipients
+  attr_accessible :body, :subject, :global, :expires if Mailboxer.protected_attributes?
+
+  belongs_to :sender, :polymorphic => :true
+  #belongs_to :notified_object, :polymorphic => :true
+  has_many :receipts, :dependent => :destroy
+
+  validates_presence_of :body#, :subject
+  #FIN NOTIFICATION
+  attr_accessible :attachment if Mailboxer.protected_attributes?
+
+  belongs_to :conversation, :validate => true, :autosave => true
+  validates_presence_of :sender
+
+  class_attribute :on_deliver_callback
+  protected :on_deliver_callback
+  scope :conversation, lambda { |conversation|
+    where(:conversation_id => conversation.id)
+  }
+  #AJOUT DEPUIS NOTIFICATION + modification de notifications en messages
+  scope :recipient, lambda { |recipient|
+    joins(:receipts).where('receipts.receiver_id' => recipient.id,'receipts.receiver_type' => recipient.class.base_class.to_s)
+  }
+  #scope :with_object, lambda { |obj|
+  #  where('notified_object_id' => obj.id,'notified_object_type' => obj.class.to_s)
+  #}
+  scope :not_trashed, lambda {
+    joins(:receipts).where('receipts.trashed' => false)
+  }
+  scope :unread,  lambda {
+    joins(:receipts).where('receipts.is_read' => false)
+  }
+  scope :global, lambda { where(:global => true) }
+  scope :expired, lambda { where("messages.expires < ?", Time.now) }
+  scope :unexpired, lambda {
+    where("messages.expires is NULL OR messages.expires > ?", Time.now)
+  }
+  #FIN NOTIFICATION
+
+  mount_uploader :attachment, AttachmentUploader
+
+  include Concerns::ConfigurableMailer
+
+  class << self
+    #Sets the on deliver callback method.
+    def on_deliver(callback_method)
+      self.on_deliver_callback = callback_method
+    end
+
+    ##Sends a Notification to all the recipients
+    #def notify_all(recipients,subject,body,obj = nil,sanitize_text = true,notification_code=nil,send_mail=true)
+    #  notification = Notification.new({:body => body, :subject => subject})
+    #  notification.recipients = recipients.respond_to?(:each) ? recipients : [recipients]
+    #  notification.recipients = notification.recipients.uniq if recipients.respond_to?(:uniq)
+    #  notification.notified_object = obj if obj.present?
+    #  notification.notification_code = notification_code if notification_code.present?
+    #  notification.deliver sanitize_text, send_mail
+    #end
+    #
+    ##Takes a +Receipt+ or an +Array+ of them and returns +true+ if the delivery was
+    ##successful or +false+ if some error raised
+    #def successful_delivery? receipts
+    #  case receipts
+    #    when Receipt
+    #      receipts.valid?
+    #      receipts.errors.empty?
+    #    when Array
+    #      receipts.each(&:valid?)
+    #      receipts.all? { |t| t.errors.empty? }
+    #    else
+    #      false
+    #  end
+    #end
+  end
+
+  #Delivers a Message. USE NOT RECOMENDED.
+  #Use Mailboxer::Models::Message.send_message instead.
+  def deliver(reply = false, should_clean = true)
+    self.clean if should_clean
+
+    #Receiver receipts
+    temp_receipts = recipients.map { |r| build_receipt(r, 'inbox') }
+
+    #Sender receipt
+    sender_receipt = build_receipt(sender, 'sentbox', true)
+    temp_receipts << sender_receipt
+
+    temp_receipts.each(&:valid?)
+    if temp_receipts.all? { |t| t.errors.empty? }
+      temp_receipts.each(&:save!) 	#Save receipts
+      #Should send an email?
+      if Mailboxer.uses_emails
+        if Mailboxer.mailer_wants_array
+          get_mailer.send_email(self, recipients).deliver
+        else
+          recipients.each do |recipient|
+            email_to = recipient.send(Mailboxer.email_method, self)
+            get_mailer.send_email(self, recipient).deliver if email_to.present?
+          end
+        end
+      end
+      if reply
+        self.conversation.touch
+      end
+      self.recipients=nil
+      self.on_deliver_callback.call(self) unless self.on_deliver_callback.nil?
+    end
+    sender_receipt
+  end
+
+  #AJOUT DEPUIS NOTIFICATION
+  #Returns the recipients of the message
+  def recipients
+    if @recipients.blank?
+      recipients_array = Array.new
+      self.receipts.each do |receipt|
+        recipients_array << receipt.receiver
+      end
+
+      recipients_array
+    else
+      @recipients
+    end
+  end
+
+  #Returns the receipt for the participant
+  def receipt_for(participant)
+    Receipt.message(self).recipient(participant)
+  end
+
+  #Returns the receipt for the participant. Alias for receipt_for(participant)
+  def receipts_for(participant)
+    receipt_for(participant)
+  end
+
+  #Returns if the participant have read the message
+  def is_unread?(participant)
+    return false if participant.nil?
+    !self.receipt_for(participant).first.is_read
+  end
+
+  def is_read?(participant)
+    !self.is_unread?(participant)
+  end
+
+  #Returns if the participant have trashed the message
+  def is_trashed?(participant)
+    return false if participant.nil?
+    self.receipt_for(participant).first.trashed
+  end
+
+  #Returns if the participant have deleted the message
+  def is_deleted?(participant)
+    return false if participant.nil?
+    return self.receipt_for(participant).first.deleted
+  end
+
+  #Mark the message as read
+  def mark_as_read(participant)
+    return if participant.nil?
+    self.receipt_for(participant).mark_as_read
+  end
+
+  #Mark the message as unread
+  def mark_as_unread(participant)
+    return if participant.nil?
+    self.receipt_for(participant).mark_as_unread
+  end
+
+  #Move the message to the trash
+  def move_to_trash(participant)
+    return if participant.nil?
+    self.receipt_for(participant).move_to_trash
+  end
+
+  #Takes the message out of the trash
+  def untrash(participant)
+    return if participant.nil?
+    self.receipt_for(participant).untrash
+  end
+
+  #Mark the message as deleted for one of the participant
+  def mark_as_deleted(participant)
+    return if participant.nil?
+    return self.receipt_for(participant).mark_as_deleted
+  end
+
+  include ActionView::Helpers::SanitizeHelper
+
+  #Sanitizes the body and subject
+  def clean
+    unless self.subject.nil?
+      self.subject = sanitize self.subject
+    end
+    self.body = sanitize self.body
+  end
+
+  #Returns notified_object. DEPRECATED
+  def object
+    warn "DEPRECATION WARNING: use 'notify_object' instead of 'object' to get the object associated with the Message"
+    notified_object
+  end
+
+  #FIN NOTIFICATION
+
+  private
+  def build_receipt(receiver, mailbox_type, is_read = false)
+    Receipt.new.tap do |receipt|
+      #mis message à la place de notification
+      receipt.message = self
+      receipt.is_read = is_read
+      receipt.receiver = receiver
+      receipt.mailbox_type = mailbox_type
+    end
+  end
+end

data/app/models/receipt.rb

@@ -0,0 +1,176 @@
+class Receipt < ActiveRecord::Base
+  attr_accessible :trashed, :is_read, :deleted if Mailboxer.protected_attributes?
+
+  #belongs_to :notification, :validate => true, :autosave => true
+  belongs_to :message, :validate => true, :autosave => true#, :foreign_key => "message_id"
+  belongs_to :receiver, :polymorphic => :true
+  #belongs_to :message, :foreign_key => "notification_id"
+
+  validates_presence_of :receiver
+
+  scope :recipient, lambda { |recipient|
+    where(:receiver_id => recipient.id,:receiver_type => recipient.class.base_class.to_s)
+  }
+  #Notifications Scope checks type to be nil, not Notification because of STI behaviour
+  #with the primary class (no type is saved)
+  #scope :notifications_receipts, lambda { joins(:notification).where('notifications.type' => nil) }
+  #scope :messages_receipts, lambda { joins(:message).where('messages.type' => Message.to_s) }
+  scope :messages_receipts, lambda { joins(:message) }
+
+  scope :message, lambda { |message|
+    where(:message_id => message.id)
+  }
+  scope :conversation, lambda { |conversation|
+    joins(:message).where('messages.conversation_id' => conversation.id)
+  }
+  scope :sentbox, lambda { where(:mailbox_type => "sentbox") }
+  scope :inbox, lambda { where(:mailbox_type => "inbox") }
+  scope :trash, lambda { where(:trashed => true, :deleted => false) }
+  scope :not_trash, lambda { where(:trashed => false) }
+  scope :deleted, lambda { where(:deleted => true) }
+  scope :not_deleted, lambda { where(:deleted => false) }
+  scope :is_read, lambda { where(:is_read => true) }
+  scope :is_unread, lambda { where(:is_read => false) }
+
+  after_validation :remove_duplicate_errors
+  class << self
+    #Marks all the receipts from the relation as read
+    def mark_as_read(options={})
+      update_receipts({:is_read => true}, options)
+    end
+
+    #Marks all the receipts from the relation as unread
+    def mark_as_unread(options={})
+      update_receipts({:is_read => false}, options)
+    end
+
+    #Marks all the receipts from the relation as trashed
+    def move_to_trash(options={})
+      update_receipts({:trashed => true}, options)
+    end
+
+    #Marks all the receipts from the relation as not trashed
+    def untrash(options={})
+      update_receipts({:trashed => false}, options)
+    end
+
+    #Marks the receipt as deleted
+    def mark_as_deleted(options={})
+      update_receipts({:deleted => true}, options)
+    end
+
+    #Marks the receipt as not deleted
+    def mark_as_not_deleted(options={})
+      update_receipts({:deleted => false}, options)
+    end
+
+    #Moves all the receipts from the relation to inbox
+    def move_to_inbox(options={})
+      update_receipts({:mailbox_type => :inbox, :trashed => false}, options)
+    end
+
+    #Moves all the receipts from the relation to sentbox
+    def move_to_sentbox(options={})
+      update_receipts({:mailbox_type => :sentbox, :trashed => false}, options)
+    end
+
+    #This methods helps to do a update_all with table joins, not currently supported by rails.
+    #Acording to the github ticket https://github.com/rails/rails/issues/522 it should be
+    #supported with 3.2.
+    def update_receipts(updates,options={})
+      ids = Array.new
+      where(options).each do |rcp|
+        ids << rcp.id
+      end
+      unless ids.empty?
+        conditions = [""].concat(ids)
+        condition = "id = ? "
+        ids.drop(1).each do
+          condition << "OR id = ? "
+        end
+        conditions[0] = condition
+        Receipt.except(:where).except(:joins).where(conditions).update_all(updates)
+      end
+    end
+  end
+
+
+  #Marks the receipt as deleted
+  def mark_as_deleted
+    update_attributes(:deleted => true)
+  end
+
+  #Marks the receipt as not deleted
+  def mark_as_not_deleted
+    update_attributes(:deleted => false)
+  end
+
+  #Marks the receipt as read
+  def mark_as_read
+    update_attributes(:is_read => true)
+  end
+
+  #Marks the receipt as unread
+  def mark_as_unread
+    update_attributes(:is_read => false)
+  end
+
+  #Marks the receipt as trashed
+  def move_to_trash
+    update_attributes(:trashed => true)
+  end
+
+  #Marks the receipt as not trashed
+  def untrash
+    update_attributes(:trashed => false)
+  end
+
+  #Moves the receipt to inbox
+  def move_to_inbox
+    update_attributes(:mailbox_type => :inbox, :trashed => false)
+  end
+
+  #Moves the receipt to sentbox
+  def move_to_sentbox
+    update_attributes(:mailbox_type => :sentbox, :trashed => false)
+  end
+
+  #Returns the conversation associated to the receipt if the notification is a Message
+  def conversation
+    message.conversation #if message.is_a? Message
+  end
+
+  #Returns if the participant have read the message
+  def is_unread?
+    !self.is_read
+  end
+
+  #Returns if the participant have trashed the message
+  def is_trashed?
+    self.trashed
+  end
+
+  protected
+
+  #Removes the duplicate error about not present subject from Conversation if it has been already
+  #raised by Message
+  def remove_duplicate_errors
+    if self.errors["message.conversation.subject"].present? and self.errors["message.subject"].present?
+      self.errors["message.conversation.subject"].each do |msg|
+        self.errors["message.conversation.subject"].delete(msg)
+      end
+    end
+  end
+
+  if Mailboxer.search_enabled
+    searchable do
+      text :subject, :boost => 5 do
+        message.subject if message
+      end
+      text :body do
+        message.body if message
+      end
+      integer :receiver_id
+    end
+  end
+end