curationexperts-mailboxer 0.10.3.rc1

data/app/models/mailbox.rb

@@ -0,0 +1,121 @@
+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 = Notification.recipient(@messageable).where(:type => nil).order("notifications.created_at DESC")
+    if (options[:read].present? and options[:read]==false) or (options[:unread].present? and options[:unread]==true)
+      notifs = notifs.unread
+    end
+    return 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)
+      end
+    end
+
+    if (options.has_key?(:read) && options[:read]==false) || (options.has_key?(:unread) && options[:unread]==true)
+      conv = conv.unread(@messageable)
+    end
+
+    return 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')
+    return 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')
+    return 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')
+    return self.conversations(options)
+  end
+
+  #Returns all the receipts of messageable, from Messages and Notifications
+  def receipts(options = {})
+    return Receipt.where(options).recipient(@messageable)
+  end
+
+  #Deletes all the messages in the trash of messageable. NOT IMPLEMENTED.
+  def empty_trash(options = {})
+    #TODO
+    return false
+  end
+
+  #Returns if messageable is a participant of conversation
+  def has_conversation?(conversation)
+    return conversation.is_participant?(@messageable)
+  end
+
+  #Returns true if messageable has at least one trashed message of the conversation
+  def is_trashed?(conversation)
+    return conversation.is_trashed?(@messageable)
+  end
+
+  #Returns true if messageable has trashed all the messages of the conversation
+  def is_completely_trashed?(conversation)
+    return 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
+      return object.receipt_for(@messageable)
+    when Conversation
+      return object.receipts_for(@messageable)
+    else
+    return nil
+    end
+  end
+
+end

data/app/models/message.rb

@@ -0,0 +1,66 @@
+class Message < Notification
+  attr_accessible :attachment if Rails::VERSION::MAJOR == 3
+
+  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)
+  }
+
+  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
+  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
+    temp_receipts = Array.new
+    #Receiver receipts
+    self.recipients.each do |r|
+      msg_receipt = Receipt.new
+      msg_receipt.notification = self
+      msg_receipt.is_read = false
+      msg_receipt.receiver = r
+      msg_receipt.mailbox_type = "inbox"
+      temp_receipts << msg_receipt
+    end
+    #Sender receipt
+    sender_receipt = Receipt.new
+    sender_receipt.notification = self
+    sender_receipt.is_read = true
+    sender_receipt.receiver = self.sender
+    sender_receipt.mailbox_type = "sentbox"
+    temp_receipts << sender_receipt
+
+    temp_receipts.each(&:valid?)
+    if temp_receipts.all? { |t| t.errors.empty? }
+      temp_receipts.each(&:save!) 	#Save receipts
+      self.recipients.each do |r|
+      #Should send an email?
+        if Mailboxer.uses_emails
+          email_to = r.send(Mailboxer.email_method,self)
+          unless email_to.blank?
+            get_mailer.send_email(self,r).deliver
+          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
+    return sender_receipt
+  end
+end

data/app/models/notification.rb

@@ -0,0 +1,184 @@
+class Notification < ActiveRecord::Base
+  attr_accessor :recipients
+  attr_accessible :body, :subject, :global, :expires if Rails::VERSION::MAJOR == 3
+
+  belongs_to :sender, :polymorphic => :true
+  belongs_to :notified_object, :polymorphic => :true
+  validates_presence_of :subject, :body
+  has_many :receipts, :dependent => :destroy
+
+  scope :recipient, lambda { |recipient|
+    joins(:receipts).where('receipts.receiver_id' => recipient.id,'receipts.receiver_type' => recipient.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("notifications.expires < ?", Time.now) }
+  scope :unexpired, lambda {
+    where("notifications.expires is NULL OR notifications.expires > ?", Time.now)
+  }
+
+  include Concerns::ConfigurableMailer
+
+  class << self
+    #Sends a Notification to all the recipients
+    def notify_all(recipients,subject,body,obj = nil,sanitize_text = true,notification_code=nil)
+      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?
+      return notification.deliver sanitize_text
+    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?
+        return receipts.errors.empty?
+       when Array
+         receipts.each(&:valid?)
+         return receipts.all? { |t| t.errors.empty? }
+       else
+         return false
+       end
+    end
+  end
+
+  def expired?
+    return self.expires.present? && (self.expires < Time.now)
+  end
+
+  def expire!
+    unless self.expired?
+      self.expire
+      self.save
+    end
+  end
+
+  def expire
+    unless self.expired?
+      self.expires = Time.now - 1.second
+    end
+  end
+
+  #Delivers a Notification. USE NOT RECOMENDED.
+  #Use Mailboxer::Models::Message.notify and Notification.notify_all instead.
+  def deliver(should_clean = true)
+    self.clean if should_clean
+    temp_receipts = Array.new
+    #Receiver receipts
+    self.recipients.each do |r|
+      msg_receipt = Receipt.new
+      msg_receipt.notification = self
+      msg_receipt.is_read = false
+      msg_receipt.receiver = r
+      temp_receipts << msg_receipt
+    end
+    temp_receipts.each(&:valid?)
+    if temp_receipts.all? { |t| t.errors.empty? }
+      temp_receipts.each(&:save!)   #Save receipts
+      self.recipients.each do |r|
+        #Should send an email?
+        if Mailboxer.uses_emails
+          email_to = r.send(Mailboxer.email_method,self)
+          unless email_to.blank?
+            get_mailer.send_email(self,r).deliver
+          end
+        end
+      end
+      self.recipients=nil
+    end
+    return temp_receipts if temp_receipts.size > 1
+    return temp_receipts.first
+  end
+
+  #Returns the recipients of the Notification
+  def recipients
+    if @recipients.blank?
+      recipients_array = Array.new
+      self.receipts.each do |receipt|
+        recipients_array << receipt.receiver
+      end
+    return recipients_array
+    end
+    return @recipients
+  end
+
+  #Returns the receipt for the participant
+  def receipt_for(participant)
+    return Receipt.notification(self).recipient(participant)
+  end
+
+  #Returns the receipt for the participant. Alias for receipt_for(participant)
+  def receipts_for(participant)
+    return receipt_for(participant)
+  end
+
+  #Returns if the participant have read the Notification
+  def is_unread?(participant)
+    return false if participant.nil?
+    return !self.receipt_for(participant).first.is_read
+  end
+
+  def is_read?(participant)
+    !self.is_unread?(participant)
+  end
+
+  #Returns if the participant have trashed the Notification
+  def is_trashed?(participant)
+    return false if participant.nil?
+    return self.receipt_for(participant).first.trashed
+  end
+
+  #Mark the notification as read
+  def mark_as_read(participant)
+    return if participant.nil?
+    return self.receipt_for(participant).mark_as_read
+  end
+
+  #Mark the notification as unread
+  def mark_as_unread(participant)
+    return if participant.nil?
+    return self.receipt_for(participant).mark_as_unread
+  end
+
+  #Move the notification to the trash
+  def move_to_trash(participant)
+    return if participant.nil?
+    return self.receipt_for(participant).move_to_trash
+  end
+
+  #Takes the notification out of the trash
+  def untrash(participant)
+    return if participant.nil?
+    return self.receipt_for(participant).untrash
+  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 Notification"
+    notified_object
+  end
+
+end

data/app/models/receipt.rb

@@ -0,0 +1,151 @@
+class Receipt < ActiveRecord::Base
+  belongs_to :notification, :validate => true, :autosave => true
+  belongs_to :receiver, :polymorphic => :true
+  belongs_to :message, :foreign_key => "notification_id"
+
+  validates_presence_of :receiver
+  attr_accessible :trashed, :is_read if Rails::VERSION::MAJOR == 3
+
+  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(:notification).where('notifications.type' => Message.to_s) }
+  scope :notification, lambda { |notification|
+    where(:notification_id => notification.id)
+  }
+  scope :conversation, lambda { |conversation|
+    joins(:message).where('notifications.conversation_id' => conversation.id)
+  }
+  scope :sentbox, lambda { where(:mailbox_type => "sentbox") }
+  scope :inbox, lambda { where(:mailbox_type => "inbox") }
+  scope :trash, lambda { where(:trashed => true) }
+  scope :not_trash, lambda { where(:trashed => 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
+
+    #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
+      return if 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
+
+  #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
+    return message.conversation if message.is_a? Message
+    return nil
+  end
+
+  #Returns if the participant have read the Notification
+  def is_unread?
+    return !self.is_read
+  end
+
+  #Returns if the participant have trashed the Notification
+  def is_trashed?
+    return 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["notification.conversation.subject"].present? and self.errors["notification.subject"].present?
+      self.errors["notification.conversation.subject"].each do |msg|
+        self.errors["notification.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