message_train 0.1.7 → 0.2.0

data/app/models/message_train/conversation.rb

@@ -3,40 +3,26 @@ module MessageTrain
     has_many :messages
     has_many :ignores
     has_many :receipts, through: :messages
+    has_many :attachments, through: :messages
 
     # Scopes
-    default_scope { order('updated_at DESC') }
-    scope :ignored, ->(participant) { where('id IN (?)', ignored_ids_for(participant))}
-    scope :unignored, ->(participant) {
-      ignored_ids = ignored_ids_for(participant)
-      if ignored_ids.empty?
-        all
-      else
-        where('NOT(id IN (?))', ignored_ids)
-      end
-    }
-    scope :filter_by_receipt_method_ids, ->(receipt_method, participant) {
-      all.collect { |x| x.receipts.send(receipt_method, participant).conversation_ids }.flatten.uniq
-    }
-    scope :filter_by_receipt_method, ->(receipt_method, participant) {
-      where('id IN (?)', filter_by_receipt_method_ids(receipt_method, participant))
-    }
-    scope :with_drafts_by, ->(participant) {
-      ids_with_drafts = all.collect { |x| x.messages.drafts.by(participant).conversation_ids }.flatten.uniq
-      where('id IN (?)', ids_with_drafts)
-    }
-    scope :with_ready_for, ->(participant) {
-      ids_with_ready = all.collect { |x| x.messages.ready.with_receipts_for(participant).conversation_ids }.flatten.uniq
-      where('id IN (?)', ids_with_ready)
-    }
+    default_scope { order(updated_at: :desc) }
+    scope :ignored, ->(participant) { where(id: ignored_ids_for(participant))}
+    scope :unignored, ->(participant) { where.not(id: ignored_ids_for(participant)) }
+    scope :with_drafts_by, ->(participant) { joins(:messages).where(message_train_messages: { id: messages.drafts.with_receipts_by(participant) }) }
+    scope :with_ready_for, ->(participant) { joins(:messages).where(message_train_messages: { id: messages.ready.with_receipts_for(participant) }) }
+    scope :with_messages_for, ->(participant) { joins(:messages).where(message_train_messages: { id: messages.with_receipts_for(participant) }) }
+    scope :with_messages_through, ->(participant) { joins(:messages).where(message_train_messages: { id: messages.with_receipts_through(participant) }) }
 
     def default_recipients_for(sender)
-      recipients = messages.with_receipts_for(sender)
-                       .collect { |x| x.receipts.collect { |y| y.recipient } }
-                       .flatten
-                       .uniq
-      recipients.delete(sender)
-      recipients
+      default_recipients = []
+      messages.with_receipts_for(sender).each do |conversation|
+        conversation.receipts.each do |receipt|
+          default_recipients << receipt.recipient
+        end
+      end
+      default_recipients.delete(sender)
+      default_recipients.flatten.uniq
     end
 
     def set_ignored(participant)
@@ -56,17 +42,30 @@ module MessageTrain
     end
 
     def mark(mark, participant)
+      # # This fixed a bug that only Travis seemed to pick up, but it's code smell.
+      # if messages.nil?
+      #   return false
+      # end
       messages.mark(mark, participant)
     end
 
-    def includes_drafts_by?(participant)
-      !messages.drafts_by(participant).empty?
+    def self.messages
+      MessageTrain::Message.joins(:conversation).where(conversation: where(nil))
     end
 
     def method_missing(method_sym, *arguments, &block)
       # the first argument is a Symbol, so you need to_s it if you want to pattern match
-      if method_sym.to_s =~ /^includes_(.*_(by|to|for))\?$/
-        !receipts.send($1.to_sym, arguments.first).empty?
+      if method_sym.to_s =~ /^includes_((.*)_(by|to|for|through))\?$/
+        case $2
+          when 'ready', 'drafts'
+            if $3 == 'by'
+              !messages.send($2).by(arguments.first).empty?
+            else
+              !messages.send($2).receipts.send("receipts_#{$3}".to_sym, arguments.first).empty?
+            end
+          else
+            !receipts.send($1.to_sym, arguments.first).empty?
+        end
       else
         super
       end
@@ -74,8 +73,15 @@ module MessageTrain
 
     def self.method_missing(method_sym, *arguments, &block)
       # the first argument is a Symbol, so you need to_s it if you want to pattern match
-      if method_sym.to_s =~ /^with_((.*)_(by|to|for))$/
-        self.filter_by_receipt_method($1.to_sym, arguments.first)
+      if method_sym.to_s =~ /^with_((.*)_(by|to|for|through))$/
+        case $2
+          when 'ready', 'drafts'
+            self.messages.send($2).filter_by_receipt_method("receipts_#{$3}".to_sym, arguments.first).conversations
+          when 'messages'
+            self.messages.filter_by_receipt_method("receipts_#{$3}".to_sym, arguments.first).conversations
+          else
+            self.filter_by_receipt_method($1.to_sym, arguments.first)
+        end
       else
         super
       end
@@ -84,7 +90,7 @@ module MessageTrain
     # It's important to know Object defines respond_to to take two parameters: the method to check, and whether to include private methods
     # http://www.ruby-doc.org/core/classes/Object.html#M000333
     def respond_to?(method_sym, include_private = false)
-      if method_sym.to_s =~ /^includes_((.*)_(by|to|for))\?$/
+      if method_sym.to_s =~ /^includes_((.*)_(by|to|for|through))\?$/
         true
       else
         super
@@ -92,7 +98,7 @@ module MessageTrain
     end
 
     def self.respond_to?(method_sym, include_private = false)
-      if method_sym.to_s =~ /^(.*)_(by|to|for)$/
+      if method_sym.to_s =~ /^with_(.*)_(by|to|for|through)$/
         true
       else
         super
@@ -100,9 +106,12 @@ module MessageTrain
     end
 
     private
+      scope :filter_by_receipt_method, ->(receipt_method, participant) {
+        where(id: where(nil).messages.receipts.send(receipt_method, participant).conversation_ids)
+      }
 
       def self.ignored_ids_for(participant)
-        MessageTrain::Ignore.find_all_by_participant(participant).conversation_ids
+        MessageTrain::Ignore.find_all_by_participant(participant).pluck(:conversation_id)
       end
   end
 end

data/app/models/message_train/ignore.rb

@@ -5,14 +5,10 @@ module MessageTrain
 
     validates_presence_of :conversation, :participant
 
-    scope :find_all_by_participant, ->(participant) { where('participant_type = ? AND participant_id = ?', participant.class.name, participant.id) }
-
-    def self.conversation_ids
-      all.collect { |y| y.conversation_id }
-    end
+    scope :find_all_by_participant, ->(participant) { where(participant: participant) }
 
     def self.conversations
-      MessageTrain::Conversation.where('id IN (?)', conversation_ids )
+      MessageTrain::Conversation.joins(:ignores).where(message_train_ignores: { id: where(nil) })
     end
   end
 end

data/app/models/message_train/message.rb

@@ -18,20 +18,14 @@ module MessageTrain
     after_save :generate_receipts_or_set_draft
     after_save :set_conversation_subject_if_alone
 
+    # Nested Attributes
+    accepts_nested_attributes_for :attachments, reject_if: :all_blank, allow_destroy: true
+
     # Scopes
-    default_scope { order('updated_at DESC') }
-    scope :filter_by_receipt_method_ids, ->(receipt_method, participant) {
-      all.collect { |x| x.receipts.send(receipt_method, participant).message_ids }.flatten
-    }
-    scope :filter_by_receipt_method, ->(receipt_method, participant) {
-      where('id IN (?)', filter_by_receipt_method_ids(receipt_method, participant))
-    }
-    scope :filter_out_by_receipt_method, ->(receipt_method, participant) {
-      where('NOT(id IN (?))', filter_by_receipt_method_ids(receipt_method, participant))
-    }
-    scope :ready, -> { where('draft = ?', false) }
-    scope :drafts, -> { where('draft = ?', true) }
-    scope :by, ->(participant) { where('sender_type = ? AND sender_id = ?', participant.class.name, participant.id) }
+    default_scope { order(updated_at: :desc) }
+    scope :ready, -> { where(draft: false) }
+    scope :drafts, -> { where(draft: true) }
+    scope :by, ->(participant) { where(sender: participant) }
     scope :drafts_by, ->(participant) { drafts.by(participant) }
 
     def mark(mark_to_set, participant)
@@ -42,26 +36,34 @@ module MessageTrain
     end
 
     def self.mark(mark_to_set, participant)
-      all.each do |message|
+      where(nil).each do |message|
         message.mark(mark_to_set, participant)
       end
     end
 
     def recipients
-      receipts.recipient_receipt.collect { |x| x.recipient }
+      recips = []
+      receipts.recipient_receipt.each do |message|
+        recips << message.received_through
+      end
+      recips.uniq
     end
 
     def self.conversation_ids
-      all.collect { |y| y.conversation_id }
+      pluck(:conversation_id)
+    end
+
+    def self.receipts
+      MessageTrain::Receipt.joins(:message).where(message_train_messages: { id: where(nil) })
     end
 
     def self.conversations
-      MessageTrain::Conversation.where('id IN (?)', conversation_ids )
+      MessageTrain::Conversation.joins(:messages).where(message_train_messages: { id: where(nil) })
     end
 
     def method_missing(method_sym, *arguments, &block)
       # the first argument is a Symbol, so you need to_s it if you want to pattern match
-      if method_sym.to_s =~ /^is_((.*)_(by|to|for))\?$/
+      if method_sym.to_s =~ /^is_((.*)_(by|to|for|through))\?$/
         !receipts.send($1.to_sym, arguments.first).empty?
       elsif method_sym.to_s =~ /^mark_(.*)_for$/
         receipts.for(arguments.first).first.mark($1.to_sym)
@@ -72,7 +74,7 @@ module MessageTrain
 
     def self.method_missing(method_sym, *arguments, &block)
       # the first argument is a Symbol, so you need to_s it if you want to pattern match
-      if method_sym.to_s =~ /^with_(.*_(by|to|for))$/
+      if method_sym.to_s =~ /^with_(.*_(by|to|for|through))$/
         filter_by_receipt_method($1.to_sym, arguments.first)
       else
         super
@@ -82,7 +84,7 @@ module MessageTrain
     # It's important to know Object defines respond_to to take two parameters: the method to check, and whether to include private methods
     # http://www.ruby-doc.org/core/classes/Object.html#M000333
     def respond_to?(method_sym, include_private = false)
-      if method_sym.to_s =~ /^is_.*_(by|to|for)\?$/ || method_sym.to_s =~ /^mark_.*_for\?$/
+      if method_sym.to_s =~ /^is_.*_(by|to|for|through)\?$/ || method_sym.to_s =~ /^mark_.*_for\?$/
         true
       else
         super
@@ -90,7 +92,7 @@ module MessageTrain
     end
 
     def self.respond_to?(method_sym, include_private = false)
-      if method_sym.to_s =~ /^.*_(by|to|for)$/
+      if method_sym.to_s =~ /^.*_(by|to|for|through)$/
         true
       else
         super
@@ -98,6 +100,11 @@ module MessageTrain
     end
 
   private
+
+    scope :filter_by_receipt_method, ->(receipt_method, participant) {
+      where(id: where(nil).receipts.send(receipt_method, participant).message_ids)
+    }
+
     def create_conversation_if_blank
       if conversation.nil?
         self.conversation = Conversation.create(subject: subject)
@@ -105,7 +112,7 @@ module MessageTrain
     end
 
     def generate_sender_receipt
-      receipts.first_or_create!(recipient_type: sender.class.name, recipient_id: sender.id, sender: true)
+      receipts.first_or_create!(recipient: sender, received_through: sender, sender: true)
     end
 
     def generate_receipts_or_set_draft
@@ -119,8 +126,17 @@ module MessageTrain
             slug_column = MessageTrain.configuration.slug_columns[table.to_sym] || :slug
             if model.exists?(slug_column => slug)
               recipient = model.find_by(slug_column => slug)
-              unless conversation.is_ignored?(recipient)
-                receipts.create!(recipient_type: model_name, recipient_id: recipient.id)
+              end_recipient_method = MessageTrain.configuration.valid_recipients_methods[table.to_sym]
+              if end_recipient_method.nil?
+                unless conversation.is_ignored?(recipient)
+                  receipts.create!(recipient: recipient, received_through: recipient)
+                end
+              else
+                recipient.send(end_recipient_method).uniq.each do |end_recipient|
+                  unless conversation.is_ignored?(end_recipient) || end_recipient == sender
+                    receipts.create!(recipient: end_recipient, received_through: recipient)
+                  end
+                end
               end
             else
               errors.add :recipients_to_save, :name_not_found.l(name: slug)

data/app/models/message_train/receipt.rb

@@ -1,19 +1,23 @@
 module MessageTrain
   class Receipt < ActiveRecord::Base
     belongs_to :recipient, polymorphic: true
+    belongs_to :received_through, polymorphic: true
     belongs_to :message
     validates_presence_of :recipient, :message
 
-    default_scope { order("created_at DESC") }
+    default_scope { order(updated_at: :desc) }
     scope :sender_receipt, -> { where('sender = ?', true) }
     scope :recipient_receipt, -> { where('sender = ?', false) }
     scope :by, ->(sender) { sender_receipt.for(sender) }
     scope :for, ->(recipient) { where('recipient_type = ? AND recipient_id = ?', recipient.class.name, recipient.id) }
     scope :to, ->(recipient) { recipient_receipt.for(recipient) }
+    scope :through, ->(received_through) { where('received_through_type = ? AND received_through_id = ?', received_through.class.name, received_through.id) }
     scope :trashed, ->(setting = true) { where('marked_trash = ?', setting) }
     scope :read, ->(setting = true) { where('marked_read = ?', setting) }
     scope :deleted, ->(setting = true) { where('marked_deleted = ?', setting) }
 
+    after_create :notify
+
     def mark(mark_to_set)
       if mark_to_set.to_s =~ /^un/
         setting = false
@@ -27,29 +31,27 @@ module MessageTrain
     end
 
     def self.message_ids
-      all.collect { |y| y.message_id }
+      pluck(:message_id)
     end
 
     def self.messages
-      MessageTrain::Message.where('id IN (?)', message_ids )
+      MessageTrain::Message.joins(:receipts).where(message_train_receipts: { id: where(nil) })
     end
 
     def self.conversation_ids
-      all.collect { |y| y.message.conversation_id }
+      messages.conversation_ids
     end
 
     def self.conversations
-      MessageTrain::Conversation.where('id IN (?)', conversation_ids )
+      MessageTrain::Conversation.joins(:receipts).where(message_train_receipts: { id: where(nil) })
     end
 
     def self.method_missing(method_sym, *arguments, &block)
       # the first argument is a Symbol, so you need to_s it if you want to pattern match
-      if method_sym.to_s =~ /^receipts_(by|to|for)$/
+      if method_sym.to_s =~ /^receipts_(by|to|for|through)$/
         send($1.to_sym, arguments.first)
-      elsif method_sym.to_s =~ /^(.*)_(by|to|for)$/
+      elsif method_sym.to_s =~ /^(.*)_(by|to|for|through)$/
         send($1.to_sym).send($2.to_sym, arguments.first)
-      elsif method_sym.to_s =~ /^mark_(.*)$/
-        mark($1.to_sym)
       elsif method_sym.to_s =~ /^un(.*)$/
         send($1.to_sym, false)
       else
@@ -60,11 +62,19 @@ module MessageTrain
     # It's important to know Object defines respond_to to take two parameters: the method to check, and whether to include private methods
     # http://www.ruby-doc.org/core/classes/Object.html#M000333
     def self.respond_to?(method_sym, include_private = false)
-      if method_sym.to_s =~ /^(.*)_(by|to|for)$/ || method_sym.to_s =~ /^(un|mark_)(.*)$/
+      if method_sym.to_s =~ /^(.*)_(by|to|for|through)$/ || method_sym.to_s =~ /^un(.*)$/
         true
       else
         super
       end
     end
+
+  private
+
+    def notify
+      unless sender? or recipient.unsubscribed_from?(received_through)
+        ReceiptMailer.notification_email(self).deliver_later
+      end
+    end
   end
 end

data/app/models/message_train/unsubscribe.rb

@@ -0,0 +1,7 @@
+module MessageTrain
+  class Unsubscribe < ActiveRecord::Base
+    belongs_to :recipient, polymorphic: true
+    belongs_to :from, polymorphic: true
+    validates_presence_of :recipient, :from
+  end
+end

data/app/views/layouts/mailer.html.haml

@@ -0,0 +1,6 @@
+!!!
+%html{ lang: "en" }
+  %head
+  %body
+    #wrapper
+      =yield

data/app/views/message_train/application/_attachment_fields.html.haml

@@ -0,0 +1,7 @@
+.nested-fields.panel.panel-default
+  .panel-body
+    = link_to_remove_association '×'.html_safe, f, title: :remove_attachment.l, class: 'close', data: { confirm: :are_you_sure.l }
+    - if f.object.attachment.exists?
+      .attachment
+        = attachment_link(f.object)
+    = f.file_field :attachment

data/app/views/message_train/application/_attachment_link.html.haml

@@ -0,0 +1,4 @@
+- if attachment.image?
+  = link_to attachment_icon(attachment), '#', class: 'thumbnail', data: { toggle: 'modal', target: '#attachment_preview', src: attachment.attachment.url(:large), original: attachment.attachment.url, text: :click_for_original.l }
+- else
+  = link_to attachment_icon(attachment), attachment.attachment.url, class: 'thumbnail'

data/app/views/message_train/application/_widget.html.haml

@@ -0,0 +1,6 @@
+- if @collective.nil?
+  - add_widget do
+    = boxes_widget @box_user
+- else
+  - add_widget do
+    = collective_boxes_widget @collective, @box_user

data/app/views/message_train/boxes/_dropdown_list.html.haml

@@ -1,5 +1,4 @@
 - unless boxes.empty?
   = dropdown_nav_item "#{:box_title_in.l} #{badge boxes.first.unread_count.to_s}".html_safe, '#' do
     - boxes.each do |box|
-      = box_nav_item box
-  = nav_item :compose.l, message_train.new_box_message_path(:in)
+      = box_nav_item box

data/app/views/message_train/boxes/_list_item.html.haml

@@ -1,5 +1,5 @@
 - if box.present?
   %li{ html_options }
     = link_to box.title, message_train.box_path(box.division)
-    - if box.unread_count > 0
-      = badge box.unread_count.to_s
+    - if unread_count > 0
+      = badge unread_count.to_s

data/app/views/message_train/boxes/_widget.html.haml

@@ -3,4 +3,7 @@
   .text-center= link_to :compose.l, message_train.new_box_message_path(:in), class: 'btn btn-lg btn-primary btn-compose'
   %ul.list-group
     - boxes.each do |box|
-      = box_list_item box, class: 'list-group-item'
+      - if @collective.nil?
+        = box_list_item box, class: 'list-group-item'
+      - else
+        = collective_list_item box, class: 'list-group-item'

data/app/views/message_train/boxes/show.html.haml

@@ -1,5 +1,10 @@
-- add_title @box.title
-= form_tag message_train.box_path(@box.division), method: :put, remote: true, id: 'box', data: { type: :json } do
+- if @collective.nil?
+  - add_title @box.title
+  - marking_path = message_train.box_path(@box.division)
+- else
+  - add_title collective_name(@collective) + ' ' + @box.title
+  - marking_path = message_train.collective_box_path(@collective.path_part, @box.division)
+= form_tag marking_path, method: :put, remote: true, id: 'box', data: { type: :json } do
   - unless @conversations.empty?
     #box-actions
       .btn-group.check-all
@@ -39,9 +44,12 @@
           - else
             %li
               = link_to :mark_as_name.l(name: :ignored.l), '#0', class: 'mark', id: 'mark-ignored', data: { mark: 'ignore'}
-      = link_to :compose.l, message_train.new_box_message_path(@box.division), class: 'btn btn-primary'
+      - if @collective.nil?
+        = link_to :compose.l, message_train.new_box_message_path(@box.division), class: 'btn btn-primary compose'
+      - elsif @collective.allows_sending_by? @box_user
+        = link_to :compose_to_collective.l(collective: collective_name(@collective)), message_train.new_collective_box_message_path(@collective.path_part, @box.division), class: 'btn btn-primary compose'
       %span#spinner.hide= icon 'refresh spinning'
       = hidden_field_tag :mark_to_set
     %table#message_train_conversations.table.table-condensed
       = render @conversations
-    = paginate @conversations
+    = paginate @conversations

data/app/views/message_train/collectives/_dropdown_list.html.haml

@@ -0,0 +1,6 @@
+- unless collective_boxes.empty?
+  - collective_boxes.each do |key, boxes|
+    - if show[key]
+      = dropdown_nav_item "#{key.to_s.humanize} #{badge total_unread_count[key].to_s}".html_safe, '#' do
+        - boxes.each do |box|
+          = collective_nav_item box, box_user

data/app/views/message_train/collectives/_list_item.html.haml

@@ -0,0 +1,5 @@
+- if box.present?
+  %li{ html_options }
+    = link_to box.title, message_train.collective_box_path(box.parent.path_part, box.division)
+    - if unread_count > 0
+      = badge unread_count.to_s

data/app/views/message_train/collectives/_widget.html.haml

@@ -0,0 +1,7 @@
+- unless collective.boxes_for_participant(box_user).empty?
+  %h3= :collective_messages.l(collective: collective_name(collective))
+  - if collective.allows_sending_by?(box_user)
+    .text-center= link_to :compose_to_collective.l(collective: collective_name(collective)), message_train.new_collective_box_message_path(collective.path_part, :sent), class: 'btn btn-lg btn-primary btn-compose'
+  %ul.list-group
+    - collective.boxes_for_participant(box_user).each do |box|
+      = collective_list_item box, class: 'list-group-item'

data/app/views/message_train/conversations/_conversation.html.haml

@@ -1,9 +1,24 @@
 %tr.message_train_conversation{ class: conversation_class(@box, conversation), id: 'message_train_conversation_' + conversation.id.to_s }
   %td.col-xs-1= check_box_tag "objects[conversations][#{conversation.id.to_s}]", conversation.id
-  %td.col-xs-2= link_to conversation_senders(conversation), message_train.box_conversation_path(@box.division, conversation)
-  %td.col-xs-8= link_to conversation.subject, message_train.box_conversation_path(@box.division, conversation)
-  %td.col-xs-1.conversation-actions
-    = conversation_read_toggle conversation
-    = conversation_trashed_toggle conversation
-    - if @box.division == :trash
-      = conversation_deleted_toggle conversation
+  - if @collective.nil?
+    %td.col-xs-2= link_to conversation_senders(conversation), message_train.box_conversation_path(@box.division, conversation)
+    %td.col-xs-8= link_to conversation.subject, message_train.box_conversation_path(@box.division, conversation)
+    %td
+      - if conversation.attachments.any?
+        = icon 'paperclip'
+    %td.col-xs-1.conversation-actions
+      = conversation_trashed_toggle conversation
+      - if @box.division == :trash
+        = conversation_deleted_toggle conversation
+    %td.col-xs-1.date-column= fuzzy_date(conversation.updated_at)
+  - else
+    %td.col-xs-2= link_to conversation_senders(conversation), message_train.collective_box_conversation_path(@collective.path_part, @box.division, conversation)
+    %td.col-xs-8= link_to conversation.subject, message_train.collective_box_conversation_path(@collective.path_part, @box.division, conversation)
+    %td
+      - if conversation.attachments.any?
+        = icon 'paperclip'
+    %td.col-xs-1.conversation-actions
+      = conversation_trashed_toggle conversation, @collective
+      - if @box.division == :trash
+        = conversation_deleted_toggle conversation, @collective
+    %td.col-xs-1.date-column= fuzzy_date(conversation.updated_at)

data/app/views/message_train/conversations/_deleted_toggle.html.haml

@@ -1 +1 @@
-= conversation_toggle conversation, 'remove', :deleted, :put, :mark_as_name.l(name: :deleted.l), data: { confirm: :delete_forever_this_cannot_be_undone.l }
+= conversation_toggle conversation, 'remove', :deleted, :put, :mark_as_name.l(name: :deleted.l), data: { confirm: :delete_forever_this_cannot_be_undone.l }, collective: collective

data/app/views/message_train/conversations/_ignored_toggle.html.haml

@@ -1,4 +1,4 @@
-- if conversation.is_ignored?(@box.parent)
-  = conversation_toggle conversation, 'volume-up', :unignore, :delete, :mark_as_name.l(name: :unignored.l)
+- if conversation.is_ignored?(@box_user)
+  = conversation_toggle conversation, 'volume-up', :unignore, :delete, :mark_as_name.l(name: :unignored.l), collective: collective
 - else
-  = conversation_toggle conversation, 'volume-off', :ignore, :delete, :mark_as_name.l(name: :ignored.l), data: { confirm: :are_you_sure.l}
+  = conversation_toggle conversation, 'volume-off', :ignore, :delete, :mark_as_name.l(name: :ignored.l), data: { confirm: :are_you_sure.l}, collective: collective

data/app/views/message_train/conversations/_read_toggle.html.haml

@@ -1,4 +1,4 @@
-- if conversation.includes_unread_for?(@box.parent)
-  = conversation_toggle conversation, 'eye-open', :read, :put, :mark_as_name.l(name: :read.l)
+- if conversation.includes_unread_for?(@box_user)
+  = conversation_toggle conversation, 'eye-open', :read, :put, :mark_as_name.l(name: :read.l), collective: collective
 - else
-  = conversation_toggle conversation, 'eye-close', :unread, :put, :mark_as_name.l(name: :unread.l)
+  = conversation_toggle conversation, 'eye-close', :unread, :put, :mark_as_name.l(name: :unread.l), collective: collective

data/app/views/message_train/conversations/_toggle.html.haml

@@ -1 +1,4 @@
-= icon_link_to icon, '', message_train.box_path(@box.division, objects: { 'conversations' => {conversation.id.to_s => conversation.id.to_s}}, mark_to_set: mark_to_set, format: :json), options
+- if options[:collective].nil?
+  = icon_link_to icon, '', message_train.box_path(@box.division, objects: { 'conversations' => {conversation.id.to_s => conversation.id.to_s}}, mark_to_set: mark_to_set, format: :json), options
+- else
+  = icon_link_to icon, '', message_train.collective_box_path(options[:collective].path_part, @box.division, objects: { 'conversations' => {conversation.id.to_s => conversation.id.to_s}}, mark_to_set: mark_to_set, format: :json), options

data/app/views/message_train/conversations/_trashed_toggle.html.haml

@@ -1,4 +1,4 @@
-- if conversation.includes_untrashed_for?(@box.parent)
-  = conversation_toggle conversation, 'trash', :trash, :put, :mark_as_name.l(name: :trashed.l), data: { confirm: :are_you_sure.l}
+- if conversation.includes_untrashed_for?(@box_user)
+  = conversation_toggle conversation, 'trash', :trash, :put, :mark_as_name.l(name: :trashed.l), data: { confirm: :are_you_sure.l}, collective: collective
 - else
-  = conversation_toggle conversation, 'inbox', :untrash, :put, :mark_as_name.l(name: :untrashed.l)
+  = conversation_toggle conversation, 'inbox', :untrash, :put, :mark_as_name.l(name: :untrashed.l), collective: collective

data/app/views/message_train/conversations/show.html.haml

@@ -1,6 +1,5 @@
 - add_title @conversation.subject
-- add_subtitle :started_at_time.l(time: @conversation.created_at)
-
+- add_subtitle :updated_at_time.l(time: @conversation.updated_at)
 #box
   #conversation-actions.pull-right
     .btn.btn-default.btn-lg= conversation_ignored_toggle(@conversation)
@@ -8,4 +7,6 @@
     - unless @messages.empty?
       #message_train_messages.messages.panel-group{aria: { multiselectable: 'true' }, role: "tablist"}
         = render @messages
-      = paginate @messages
+      = paginate @messages
+= modal 'attachment_preview', :attachment_preview.l do
+  #image_placeholder

data/app/views/message_train/messages/_deleted_toggle.html.haml

@@ -1 +1 @@
-= message_toggle message, 'remove', :deleted, :mark_as_name.l(name: :deleted.l)
+= message_toggle message, 'remove', :deleted, :mark_as_name.l(name: :deleted.l), data: { confirm: :delete_forever_this_cannot_be_undone.l }

data/app/views/message_train/messages/_form.html.haml

@@ -1,8 +1,23 @@
-- resource = message.new_record? ? message_train.box_messages_path(@box) : message_train.box_message_path(@box, message)
+- if @collective.nil?
+  - resource = message.new_record? ? message_train.box_messages_path(@box) : message_train.box_message_path(@box, message)
+- else
+  - resource = message.new_record? ? message_train.collective_box_messages_path(@collective.path_part, @box) : message_train.collective_box_message_path(@collective.path_part, @box, message)
 = bootstrap_form_for message, url: resource do |f|
-  - MessageTrain.configuration.recipient_tables.each do |table_sym, class_name|
-    = render partial: 'message_train/participants/field', locals: { message: message, field_name: table_sym }
-  = f.text_field :subject
-  = f.text_area :body
-  = f.check_box :draft
-  = f.submit :send.l
+  .row
+    .col-md-8
+      - if @collective.nil?
+        = render partial: 'message_train/participants/field', locals: { message: message, field_name: :users }
+      - else
+        = render partial: 'message_train/participants/prefilled_field', locals: { message: message, recipient: @collective }
+      = f.text_field :subject
+      = f.text_area :body, class: 'wysiwyg'
+    .col-md-4
+      .links
+        .pull-right= link_to_add_association(icon('plus'), f, :attachments, title: :add_attachment.l, class: 'btn btn-info', id: 'add-attachment', data: { association_insertion_method: 'append', association_insertion_node: '#attachments'})
+        %h3
+          = :attachments.l
+      #attachments
+        = f.fields_for :attachments do |attachment|
+          = render 'attachment_fields', f: attachment
+  = f.submit :save_as_draft.l, name: 'message[draft]'
+  = f.submit :send.l, class: 'btn btn-primary', name: 'message[draft]'