message_train 0.1.7 → 0.2.0

data/app/helpers/message_train/collectives_helper.rb

@@ -0,0 +1,48 @@
+module MessageTrain
+  module CollectivesHelper
+
+    def collective_boxes_widget(collective, box_user)
+      render partial: 'message_train/collectives/widget', locals: { collective: collective, box_user: box_user }
+    end
+
+    def collective_nav_item(box, box_user)
+      text = collective_name(box.parent)
+      if box.parent.allows_receiving_by? box_user
+        division = :in
+      elsif box.parent.allows_sending_by? box_user
+        division = :sent
+      else
+        return
+      end
+      link = message_train.collective_box_path(box.parent.path_part, division)
+      unread_count = box.unread_count
+      if unread_count > 0
+        text << badge(unread_count.to_s, 'info pull-right')
+      end
+      nav_item text.html_safe, link
+    end
+
+    def collective_list_item(box, html_options = {})
+      render partial: 'message_train/collectives/list_item', locals: { box: box, html_options: html_options, unread_count: box.unread_count }
+    end
+
+    def collective_boxes_dropdown_list(box_user)
+      total_unread_count = {}
+      show = {}
+      box_user.collective_boxes.each do |table_sym, collectives|
+        total_unread_count[table_sym] = collectives.collect { |collective_box| collective_box.unread_count }.sum
+        show[table_sym] = collectives.select { |collective_box| collective_box.parent.allows_sending_by?(box_user) || collective_box.parent.allows_receiving_by?(box_user) }.any?
+      end
+      render partial: 'message_train/collectives/dropdown_list', locals: { collective_boxes: box_user.collective_boxes, total_unread_count: total_unread_count, show: show, box_user: box_user }
+    end
+
+    def collective_name(collective)
+      collective.send(MessageTrain.configuration.name_columns[collective.class.table_name.to_sym])
+    end
+
+    def collective_slug(collective)
+      collective.send(MessageTrain.configuration.slug_columns[collective.class.table_name.to_sym])
+    end
+
+  end
+end

data/app/helpers/message_train/conversations_helper.rb

@@ -1,40 +1,44 @@
 module MessageTrain
   module ConversationsHelper
     def conversation_senders(conversation)
-      conversation.messages.collect { |x| box_participant_name(x.sender) }.uniq.to_sentence
+      names = []
+      conversation.messages.each do |message|
+        names << box_participant_name(message.sender)
+      end
+      names.uniq.to_sentence
     end
 
     def conversation_class(box, conversation)
       css_classes = []
 
-      if conversation.includes_unread_for?(@box.parent)
+      if conversation.includes_unread_for?(@box_user)
         css_classes << 'unread'
       else
         css_classes << 'read'
       end
 
-      if conversation.includes_drafts_by?(@box.parent)
+      if conversation.includes_drafts_by?(@box_user)
         css_classes << 'draft'
       end
 
-      unless conversation.includes_undeleted_for?(box.parent)
+      unless conversation.includes_undeleted_for?(@box_user)
         css_classes << 'hide'
       end
 
       if box.division == :trash
-        unless conversation.includes_trashed_for?(box.parent)
+        unless conversation.includes_trashed_for?(@box_user)
           css_classes << 'hide'
         end
       else
-        unless conversation.includes_untrashed_for?(box.parent)
+        unless conversation.includes_untrashed_for?(@box_user)
           css_classes << 'hide'
         end
         if box.division == :ignored
-          unless conversation.is_ignored?(box.parent)
+          unless conversation.is_ignored?(@box_user)
             css_classes << 'hide'
           end
         else
-          if conversation.is_ignored?(box.parent)
+          if conversation.is_ignored?(@box_user)
             css_classes << 'hide'
           end
         end
@@ -42,26 +46,30 @@ module MessageTrain
       css_classes.uniq.join(' ')
     end
 
-    def conversation_trashed_toggle(conversation)
-      render partial: 'message_train/conversations/trashed_toggle', locals: { conversation: conversation }
+    def conversation_trashed_toggle(conversation, collective = nil)
+      render partial: 'message_train/conversations/trashed_toggle', locals: { conversation: conversation, collective: collective }
     end
 
-    def conversation_read_toggle(conversation)
-      render partial: 'message_train/conversations/read_toggle', locals: { conversation: conversation }
+    def conversation_read_toggle(conversation, collective = nil)
+      render partial: 'message_train/conversations/read_toggle', locals: { conversation: conversation, collective: collective }
     end
 
-    def conversation_ignored_toggle(conversation)
-      render partial: 'message_train/conversations/ignored_toggle', locals: { conversation: conversation }
+    def conversation_ignored_toggle(conversation, collective = nil)
+      render partial: 'message_train/conversations/ignored_toggle', locals: { conversation: conversation, collective: collective }
     end
 
-    def conversation_deleted_toggle(conversation)
-      render partial: 'message_train/conversations/deleted_toggle', locals: { conversation: conversation }
+    def conversation_deleted_toggle(conversation, collective = nil)
+      render partial: 'message_train/conversations/deleted_toggle', locals: { conversation: conversation, collective: collective }
     end
 
+  private
+
     def conversation_toggle(conversation, icon, mark_to_set, method, title, options = {})
       options[:remote] = true
       options[:method] = method
       options[:title] = title
+      options[:class] ||= ""
+      options[:class] += " " + mark_to_set.to_s + "-toggle"
       render partial: 'message_train/conversations/toggle', locals: {
                                                             conversation: conversation,
                                                             icon: icon,

data/app/helpers/message_train/messages_helper.rb

@@ -3,7 +3,7 @@ module MessageTrain
     def message_class(box, message)
       css_classes = []
 
-      if message.is_unread_for?(@box.parent)
+      if message.is_unread_for?(@box_user)
         css_classes << 'unread panel-info'
       else
         css_classes << 'read'
@@ -14,11 +14,11 @@ module MessageTrain
       end
 
       if box.division == :trash
-        unless message.is_trashed_for?(box.parent)
+        unless message.is_trashed_for?(@box_user)
           css_classes << 'hide'
         end
       else
-        unless message.is_untrashed_for?(box.parent)
+        unless message.is_untrashed_for?(@box_user)
           css_classes << 'hide'
         end
       end
@@ -37,6 +37,12 @@ module MessageTrain
       render partial: 'message_train/messages/deleted_toggle', locals: { message: message }
     end
 
+    def message_recipients(message)
+      message.recipients.collect { |x| box_participant_name(x) }.to_sentence
+    end
+
+  private
+
     def message_toggle(message, icon, mark_to_set, title, options = {})
       options[:remote] = true
       options[:id] = "mark_#{mark_to_set}_#{message.id}"
@@ -44,15 +50,11 @@ module MessageTrain
       options[:method] = :put
       options[:title] = title
       render partial: 'message_train/messages/toggle', locals: {
-                                                            message: message,
-                                                            icon: icon,
-                                                            mark_to_set: mark_to_set,
-                                                            options: options
-                                                        }
-    end
-
-    def message_recipients(message)
-      message.recipients.collect { |x| box_participant_name(x) }.to_sentence
+                                                         message: message,
+                                                         icon: icon,
+                                                         mark_to_set: mark_to_set,
+                                                         options: options
+                                                     }
     end
   end
 end

data/app/mailers/message_train/application_mailer.rb

@@ -0,0 +1,8 @@
+module MessageTrain
+  class ApplicationMailer < ActionMailer::Base
+    default from: MessageTrain.configuration.from_email,
+        charset:       "utf-8",
+        content_type:  "text/html"
+    layout 'mailer'
+  end
+end

data/app/mailers/message_train/previews/receipt_mailer_preview.rb

@@ -0,0 +1,10 @@
+module MessageTrain
+  class ReceiptMailerPreview < ActionMailer::Preview
+
+    def notification_email
+      receipt = MessageTrain::Receipt.last
+      ReceiptMailer.notification_email(receipt)
+    end
+
+  end
+end

data/app/mailers/message_train/receipt_mailer.rb

@@ -0,0 +1,17 @@
+module MessageTrain
+  class ReceiptMailer < ApplicationMailer
+    def notification_email(receipt)
+      @receipt = receipt
+      @recipient = receipt.recipient
+      @through = receipt.received_through
+      if @recipient == @through
+        @heading = :new_message_on_site_name.l(site_name: MessageTrain.configuration.site_name)
+      else
+        @through_name = @through.send(MessageTrain.configuration.name_columns[@through.class.table_name.to_sym])
+        @heading = :new_message_through_on_site_name.l(site_name: MessageTrain.configuration.site_name, through: @through_name)
+      end
+      @subject = "#{@heading}: #{@receipt.message.subject}"
+      mail(to: @recipient.email, subject: @subject)
+    end
+  end
+end

data/app/models/message_train/attachment.rb

@@ -1,17 +1,35 @@
 module MessageTrain
   class Attachment < ActiveRecord::Base
     belongs_to :message
-    has_attached_file :attachment
+    has_attached_file :attachment, styles: lambda { |attachment|
+                                                    attachment.instance.image? ? {
+                                                      thumb: '235x',
+                                                      large: '800x'
+                                                    } : {}
+                                                  },
+                                  path: ':rails_root/public/system/:rails_env/:class/:attachment/:id_partition/:style_prefix:filename',
+                                  url: '/system/:rails_env/:class/:attachment/:id_partition/:style_prefix:filename',
+                                  convert_options: {
+                                      large: '-quality 75 -interlace Plane -strip',
+                                      thumb: '-quality 75 -strip',
+                                  }
     validates_attachment_presence :attachment
     validates_attachment_content_type :attachment, content_type: [
-                                        "application/pdf",
-                                        "application/vnd.ms-excel",
-                                        "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
-                                        "application/msword",
-                                        "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
-                                        "application/rtf",
-                                        "text/plain",
-                                        /^image\/.*$/
+                                        'application/pdf',
+                                        'application/vnd.ms-excel',
+                                        'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
+                                        'application/msword',
+                                        'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
+                                        'application/rtf',
+                                        'text/plain',
+                                        /^(image|(x-)?application)\/(bmp|gif|jpeg|jpg|pjpeg|png|x-png)$/
                                     ]
+    def image?
+      (attachment_content_type =~ /^(image|(x-)?application)\/(bmp|gif|jpeg|jpg|pjpeg|png|x-png)$/) ? true : false
+    end
+
+    Paperclip.interpolates :style_prefix do |attachment, style|
+      attachment.instance.image? ? "#{style.to_s}/" : ''
+    end
   end
-end
+end

data/app/models/message_train/box.rb

@@ -1,57 +1,62 @@
 module MessageTrain
   class Box
     include ActiveModel::Model
-    attr_accessor :parent, :division, :errors, :results
+    attr_accessor :parent, :division, :participant, :errors, :results
     alias_method :id, :division
 
-    def initialize(parent, division)
+    def initialize(parent, division, participant = nil)
       @parent = parent
+      @participant = participant || parent
       @division = division
       @results = Results.new(self)
       @errors = Errors.new(self)
     end
 
-    def marks
-      { conversations: nil }
-    end
-
     def to_param
       division.to_s
     end
 
     def unread_count
-      conversations(unread: true).count
+      found = conversations(unread: true)
+      # # This fixed a bug that only Travis seemed to pick up, but it's code smell.
+      # if found.nil?
+      #   0
+      # else
+      #   found.count
+      # end
+      found.count
     end
 
     def conversations(options = {})
-      found = parent.conversations(division).with_undeleted_for(parent)
+      found = parent.conversations(division, participant)
+      found = found.with_undeleted_for(participant)
       if options[:read] == false || options[:unread]
-        found = found.with_unread_for(parent)
+        found = found.with_unread_for(participant)
       end
       if division == :trash
-        found = found.with_trashed_for(parent)
+        found = found.with_trashed_for(participant)
       else
-        found = found.with_untrashed_for(parent)
+        found = found.with_untrashed_for(participant)
         if division == :drafts
-          found = found.with_drafts_by(parent)
+          found = found.with_drafts_by(participant)
         else
-          found = found.with_ready_for(parent)
+          found = found.with_ready_for(participant)
         end
         if division == :ignored
-          found = found.ignored(parent)
+          found = found.ignored(participant)
         else
-          found = found.unignored(parent)
+          found = found.unignored(participant)
         end
       end
       found
     end
 
     def find_conversation(id)
-      parent.all_conversations.find(id)
+      parent.all_conversations(participant).find(id)
     end
 
     def find_message(id)
-      parent.all_messages.find(id)
+      parent.all_messages(participant).find(id)
     end
 
     def new_message(args = {})
@@ -59,8 +64,10 @@ module MessageTrain
         message = MessageTrain::Message.new(args)
       else
         conversation = find_conversation(args[:conversation_id])
+        previous_message = conversation.messages.last
         message = conversation.messages.build(args)
         message.subject = "Re: #{conversation.subject}"
+        message.body = "<blockquote>#{previous_message.body}</blockquote><p>&nbsp;</p>"
         recipient_arrays = {}
         conversation.default_recipients_for(parent).each do |recipient|
           table_name = recipient.class.table_name
@@ -76,8 +83,18 @@ module MessageTrain
 
     def send_message(attributes)
       message_to_send = MessageTrain::Message.new attributes
-      message_to_send.sender = parent
-      unless message_to_send.save
+      message_to_send.sender = participant
+      unless parent.valid_senders.include? participant
+        errors.add(message_to_send, :invalid_sender_for_thing.l(thing: "#{parent.class.name} #{parent.id}"))
+        return false
+      end
+      if message_to_send.save
+        if message_to_send.draft
+          results.add(message_to_send, :message_saved_as_draft.l)
+        else
+          results.add(message_to_send, :message_sent.l)
+        end
+      else
         errors.add(message_to_send, message_to_send.errors.full_messages.to_sentence)
       end
       message_to_send
@@ -85,15 +102,23 @@ module MessageTrain
 
     def update_message(message_to_update, attributes)
       attributes.delete(:sender)
-      if message_to_update.sender == parent
+      if message_to_update.sender == participant && parent.valid_senders.include?(participant)
         message_to_update.update(attributes)
-        unless message_to_update.errors.empty?
+        message_to_update.reload
+        if message_to_update.errors.empty?
+          if message_to_update.draft
+            results.add(message_to_update, :message_saved_as_draft.l)
+          else
+            results.add(message_to_update, :message_sent.l)
+          end
+        else
           errors.add(message_to_update, message_to_update.errors.full_messages.to_sentence)
         end
+        message_to_update
       else
         errors.add(message_to_update, :access_to_message_id_denied.l(id: message_to_update.id))
+        false
       end
-      message_to_update.reload
     end
 
     def ignore(object)
@@ -103,20 +128,13 @@ module MessageTrain
         when 'Array'
           object.collect { |item| ignore(item) }.uniq == [true]
         when 'String', 'Fixnum'
-          id = object.to_i
-          object = parent.all_conversations.find_by_id(id)
-          if object.nil?
-            errors.add(self, :class_id_not_found_in_box.l(class: 'Conversation', id: id.to_s))
-          else
-            ignore(object)
-          end
+          ignore(find_conversation(object.to_i))
         when 'MessageTrain::Conversation'
           if authorize(object)
-            if object.set_ignored(parent)
-              results.add(object, :update_successful.l)
-            else
-              errors.add(object, object.errors.full_messages.to_sentence)
-            end
+            object.set_ignored(participant)
+            # We can assume the previous line has succeeded at this point, because set_ignored raises
+            # an ActiveRecord error otherwise. Therefore we simply report success, since we got here.
+            results.add(object, :update_successful.l)
           else
             false
           end
@@ -132,25 +150,18 @@ module MessageTrain
         when 'Array'
           object.collect { |item| unignore(item) }.uniq == [true]
         when 'String', 'Fixnum'
-          id = object.to_i
-          object = parent.all_conversations.find_by_id(id)
-          if object.nil?
-            errors.add(self, :class_id_not_found_in_box.l(class: 'Conversation', id: id.to_s))
-          else
-            unignore(object)
-          end
+          unignore(find_conversation(object.to_i))
         when 'MessageTrain::Conversation'
           if authorize(object)
-            if object.set_unignored(parent)
-              results.add(object, :update_successful.l)
-            else
-              errors.add(object, object.errors.full_messages.to_sentence)
-            end
+            object.set_unignored(participant)
+            # We can assume the previous line has succeeded at this point, because set_unignored raises
+            # an ActiveRecord error otherwise. Therefore we simply report success, since we got here.
+            results.add(object, :update_successful.l)
           else
             false
           end
         else
-        errors.add(self, :cannot_ignore_type.l(type: object.class.name))
+        errors.add(self, :cannot_unignore_type.l(type: object.class.name))
       end
     end
 
@@ -170,33 +181,33 @@ module MessageTrain
 
     def mark(mark_to_set, objects)
       objects.each do |key, object|
-        if object.present?
-          case object.class.name
+        if !object.present?
+          # Allow skipping empty objects
+        elsif key.to_s =~ /^(conversations|messages)$/
+          data_type = object.class.name
+          case data_type
             when 'Hash'
               mark(mark_to_set, { key => object.values } )
             when 'Array'
               object.collect { |item| mark(mark_to_set, key => item) }.uniq == [true]
             when 'String', 'Fixnum'
-              id = object.to_i
-              object = parent.send("all_#{key}".to_sym).find_by_id(id)
-              if object.nil?
-                errors.add(self, :class_id_not_found_in_box.l(class: key.to_s.classify, id: id.to_s))
-              else
-                mark(mark_to_set, key => object)
-              end
+              model_name = "MessageTrain::#{key.to_s.classify}"
+              model = model_name.constantize
+              mark(mark_to_set, key => model.find_by_id!(object.to_i))
             when 'MessageTrain::Conversation', 'MessageTrain::Message'
               if authorize(object)
-                if object.mark(mark_to_set, parent)
-                  results.add(object, :update_successful.l)
-                else
-                  errors.add(object, object.errors.full_messages.to_sentence)
-                end
+                object.mark(mark_to_set, participant)
+                # We can assume the previous line has succeeded at this point, because mark raises
+                # an ActiveRecord error otherwise. Therefore we simply report success, since we got here.
+                results.add(object, :update_successful.l)
               else
                 false
               end
             else
-            errors.add(self, :cannot_mark_type.l(type: object.class.name))
+              errors.add(self, :cannot_mark_with_data_type.l(data_type: data_type))
           end
+        else
+          errors.add(self, :cannot_mark_type.l(type: key.to_s))
         end
       end
     end
@@ -204,19 +215,19 @@ module MessageTrain
     def authorize(object)
       case object.class.name
         when 'MessageTrain::Conversation'
-          if object.includes_receipts_for? parent
+          if object.includes_receipts_for? participant
             true
           else
             errors.add(object, :access_to_conversation_id_denied.l(id: object.id))
           end
         when 'MessageTrain::Message'
-          if object.receipts.for(parent).any?
+          if object.receipts.for(participant).any?
             true
           else
             errors.add(object, :access_to_message_id_denied.l(id: object.id))
           end
         else
-          errors.add(object, :dont_know_how_to_mark_object.l(object: object.class.name))
+          errors.add(object, :cannot_authorize_type.l(type: object.class.name))
       end
     end
 
@@ -230,24 +241,44 @@ module MessageTrain
 
       def add(object, message)
         item = {}
-        if object.is_a? MessageTrain::Box
-          item[:css_id] = 'box'
-          item[:path] = MessageTrain::Engine.routes.path_for({
-                                                             controller: 'message_train/boxes',
-                                                             action: :show,
-                                                             division: object.division
-                                                         })
-        elsif object.new_record?
-          item[:css_id] = "#{object.class.table_name.singularize}"
-          item[:path] = nil
-        else
-          item[:css_id] = "#{object.class.table_name.singularize}_#{object.id.to_s}"
-          item[:path] = MessageTrain::Engine.routes.path_for({
-                                                             controller: object.class.table_name.gsub('message_train_', 'message_train/'),
-                                                             action: :show,
-                                                             box_division: box.division,
-                                                             id: object.id
-                                                         })
+        case object.class.name
+          when 'MessageTrain::Box'
+            item[:css_id] = 'box'
+            route_args = {
+                controller: 'message_train/boxes',
+                action: :show,
+                division: object.division
+            }
+            if box.parent != box.participant
+              collective = box.parent
+              table_part = collective.class.table_name
+              slug_part = collective.send(MessageTrain.configuration.slug_columns[collective.class.table_name.to_sym])
+              route_args[:collective_id] = "#{table_part}:#{slug_part}"
+            end
+            item[:path] = MessageTrain::Engine.routes.path_for(route_args)
+          when 'MessageTrain::Conversation', 'MessageTrain::Message'
+            if object.new_record?
+              item[:css_id] = "#{object.class.table_name.singularize}"
+              item[:path] = nil
+            else
+              item[:css_id] = "#{object.class.table_name.singularize}_#{object.id.to_s}"
+              route_args = {
+                  controller: object.class.table_name.gsub('message_train_', 'message_train/'),
+                  action: :show,
+                  box_division: box.division,
+                  id: object.id
+              }
+              if box.parent != box.participant
+                collective = box.parent
+                table_part = collective.class.table_name
+                slug_part = collective.send(MessageTrain.configuration.slug_columns[collective.class.table_name.to_sym])
+                route_args[:collective_id] = "#{table_part}:#{slug_part}"
+              end
+              item[:path] = MessageTrain::Engine.routes.path_for(route_args)
+            end
+          else
+            item[:css_id] = "#{object.class.name.singularize.downcase}"
+            item[:path] = nil
         end
         item[:message] = message
         items << item