mailboxer 0.5.0 → 0.5.1

data/app/models/mailbox.rb

@@ -9,7 +9,11 @@ class Mailbox
   #Returns the notifications for the messageable
   def notifications(options = {})
     #:type => nil is a hack not to give Messages as Notifications
-    return Notification.recipient(@messageable).where(:type => nil).order("notifications.created_at DESC") 
+    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
@@ -39,7 +43,7 @@ class Mailbox
     end
 
     if (options[:read].present? and options[:read]==false) or (options[:unread].present? and options[:unread]==true)
-    conv = conv.unread(@messageable)
+      conv = conv.unread(@messageable)
     end
 
     return conv.uniq

data/app/models/notification.rb

@@ -21,12 +21,27 @@ class Notification < ActiveRecord::Base
   
   class << self
     #Sends a Notification to all the recipients
-    def notify_all(recipients,subject,body,obj = nil)
+    def notify_all(recipients,subject,body,obj = nil,sanitize_text = true)
       notification = Notification.new({:body => body, :subject => subject})
       notification.recipients = recipients.is_a?(Array) ? recipients : [recipients]
       notification.recipients = notification.recipients.uniq
       notification.notified_object = obj if obj.present?
-      return notification.deliver
+      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
 

data/lib/mailboxer/models/messageable.rb

@@ -41,52 +41,52 @@ module Mailboxer
         end
 
         #Sends a notification to the messageable
-        def notify(subject,body,obj = nil)
+        def notify(subject,body,obj = nil,sanitize_text=true)
           notification = Notification.new({:body => body, :subject => subject})
           notification.recipients = [self]
           notification.notified_object = obj if obj.present?
-          return notification.deliver
+          return notification.deliver sanitize_text
         end
 
         #Sends a messages, starting a new conversation, with the messageable
         #as originator
-        def send_message(recipients, msg_body, subject)
+        def send_message(recipients, msg_body, subject,sanitize_text=true)
           convo = Conversation.new({:subject => subject})
           message = Message.new({:sender => self, :conversation => convo,  :body => msg_body, :subject => subject})
           message.recipients = recipients.is_a?(Array) ? recipients : [recipients]
           message.recipients = message.recipients.uniq
-          return message.deliver
+          return message.deliver false,sanitize_text
         end
 
         #Basic reply method. USE NOT RECOMENDED.
         #Use reply_to_sender, reply_to_all and reply_to_conversation instead.
-        def reply(conversation, recipients, reply_body, subject = nil)
+        def reply(conversation, recipients, reply_body, subject = nil,sanitize_text=true)
           subject = subject || "RE: #{conversation.subject}"
           response = Message.new({:sender => self, :conversation => conversation, :body => reply_body, :subject => subject})
           response.recipients = recipients.is_a?(Array) ? recipients : [recipients]
           response.recipients = response.recipients.uniq
           response.recipients.delete(self)
-          return response.deliver(true)
+          return response.deliver true,sanitize_text
         end
 
         #Replies to the sender of the message in the conversation
-        def reply_to_sender(receipt, reply_body, subject = nil)
-          return reply(receipt.conversation, receipt.message.sender, reply_body, subject)
+        def reply_to_sender(receipt, reply_body, subject = nil,sanitize_text=true)
+          return reply(receipt.conversation, receipt.message.sender, reply_body, subject,sanitize_text)
         end
 
         #Replies to all the recipients of the message in the conversation
-        def reply_to_all(receipt, reply_body, subject = nil)
-          return reply(receipt.conversation, receipt.message.recipients, reply_body, subject)
+        def reply_to_all(receipt, reply_body, subject = nil,sanitize_text=true)
+          return reply(receipt.conversation, receipt.message.recipients, reply_body, subject,sanitize_text)
         end
 
         #Replies to all the recipients of the last message in the conversation and untrash any trashed message by messageable
         #if should_untrash is set to true (this is so by default)
-        def reply_to_conversation(conversation, reply_body, subject = nil, should_untrash = true)
+        def reply_to_conversation(conversation, reply_body, subject = nil, should_untrash = true,sanitize_text=true)
           #move conversation to inbox if it is currently in the trash and should_untrash parameter is true.
           if should_untrash && mailbox.is_trashed?(conversation)
             mailbox.receipts_for(conversation).untrash
           end
-          return reply(conversation, conversation.last_message.recipients, reply_body, subject)
+          return reply(conversation, conversation.last_message.recipients, reply_body, subject,sanitize_text)
         end
 
         #Mark the object as read for messageable.

data/mailboxer.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
 	s.name = "mailboxer"
-	s.version = "0.5.0"
+	s.version = "0.5.1"
 	s.authors = ["Eduardo Casanova Cuesta"]
 	s.summary = "Messaging system for rails apps."
 	s.description = "A Rails engine that allows any model to act as messageable, allowing it to exchange messages " +

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: mailboxer
 version: !ruby/object:Gem::Version 
-  hash: 11
+  hash: 9
   prerelease: 
   segments: 
   - 0
   - 5
-  - 0
-  version: 0.5.0
+  - 1
+  version: 0.5.1
 platform: ruby
 authors: 
 - Eduardo Casanova Cuesta
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-27 00:00:00 +02:00
+date: 2011-09-03 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency